<template>
	<view class="page-top-bg"></view>
	<AdaptiveNavBar :showBack="true" title="合作申请管理" :showHome="false" :showShadow="false" text-color="#ffffff"
		background-color="#0081ff" />
	<view class="content-area" :style="{ marginTop: navbarTotalHeightRpx }">
		<view class="cooperation-container">
			<!-- 加载状态 -->
			<view v-if="loading" class="loading-container">
				<u-loading-icon mode="spinner" size="40" color="#3FBDA3"></u-loading-icon>
				<text class="loading-text">正在加载...</text>
			</view>

			<view v-else class="main-content">
				<!-- 产品信息卡片 -->
				<view class="main-top-period" :style="{ marginTop: navbarTotalHeightRpx }">
					<view class="product-card-wrapper">
						<ProductCard :info="productInfo" />
					</view>

					<!-- 班期选择区块 -->
					<section class="section" style="position: relative;margin: 0rpx;">
						<view class="section-header" style="padding: 20rpx 0rpx 0rpx 0rpx;">
							<view class="section-header__left">
								<FontIcon name="icon-xuanzebanqi" class="section-header__icon" size="28rpx"
									color="#787878"></FontIcon>
								<view class="section-header__title">班期</view>
							</view>
						</view>

						<!-- 班期卡片列表（默认横向滑动，不换行；点击"全部班期"展开为多行） -->
						<view v-if="selectedDates" class="period-cards-container" :class="{ expanded: showAllPeriods }">
							<view v-for="periodItem in selectedDates" :key="periodItem.periodId" class="period-card"
								:class="{
									'selected': periodItem.isSelected,
									'disabled': !isPeriodSelectable(periodItem)
								}" @tap="handlePeriodSelect(periodItem)">
								<!-- 角标：优先显示 appendingGroups，为0时显示 repliedGroups -->
								<view v-if="getPeriodBadgeValue(periodItem) > 0" class="period-badge"
									:class="getPeriodBadgeClass(periodItem)">
									{{ getPeriodBadgeValue(periodItem) }}
								</view>
								<view class="period-card__date">
									<text class="period-card__month-day">{{ formatMonthDay(periodItem.DateName)
									}}</text>
								</view>
								<view class="period-card__week">{{ periodItem.WeekName }}</view>
								<!-- 🔑 班期状态文本（待答复/已驳回） -->
								<view v-if="getPeriodStatusText(periodItem)" class="period-card__status"
									:class="{
										'status-pending': periodItem.status === 0,
										'status-rejected': periodItem.status === 5
									}">
									{{ getPeriodStatusText(periodItem) }}
								</view>
								<view v-if="periodItem.isSelected" class="period-card__selected-icon">
									<FontIcon name="icon-checked" color="#FF6B35" />
								</view>
							</view>
							<!-- 占位标签（防止被按钮遮挡） -->
							<view class="all-periods-button-spacer"></view>
							<!-- 全部班期按钮 -->
							<view class="all-periods-button" @tap.stop="chooseDate">
								<text>班期</text>
								<text>管理</text>
							</view>
							<view v-if="selectedDates.length === 0" class="empty-dates">
								<text class="empty-text" v-if="isApplyCall">暂无可选班期</text>
								<text class="empty-text" v-else>请选择班期</text>
							</view>
						</view>
					</section>
				</view>

				<!-- 已选班期信息区域 -->
				<view v-if="hasPeriodSelected" class="selected-schedule-info">
					<view class="info-header">
						<FontIcon name="icon-xuanzebanqi" class="section-header__icon" size="28rpx"></FontIcon>
						<text class="header-text" style="flex:1">已选班期</text><text
							style="font-size: 28rpx;font-weight: 700;color:#ff6b35">{{ selectedScheduleInfo ?
								selectedScheduleInfo.date : '请选择班期' }}</text>
					</view>

					<view class="info-cards">
						<view class="info-card">
							<view class="card-title">待答复</view>
							<view class="card-content">
								<view class="data-column">
									<view class="data-number red">{{ selectedScheduleInfo ?
										selectedScheduleInfo.pendingApplications.groupCount : '--' }}</view>
									<view class="data-label">{{ selectedScheduleInfo && selectedScheduleInfo.unitText ?
										selectedScheduleInfo.unitText + '数' : '团数' }}</view>
								</view>
								<view class="data-column">
									<view class="data-number orange">{{ selectedScheduleInfo ?
										selectedScheduleInfo.pendingApplications.quota : '--' }}</view>
									<view class="data-label">名额</view>
								</view>
							</view>
						</view>
						<view class="info-card">
							<view class="card-title">已答复，报名中...</view>
							<view class="card-content">
								<view class="data-column">
									<view class="data-number green">{{ selectedScheduleInfo ?
										selectedScheduleInfo.respondedApplications.registeredGroups + '/' +
										selectedScheduleInfo.respondedApplications.groupCount : '--' }}</view>
									<view class="data-label">{{ selectedScheduleInfo && selectedScheduleInfo.unitText ?
										selectedScheduleInfo.unitText + '数' : '团数' }}</view>
								</view>
								<view class="data-column">
									<view class="data-number green">{{ selectedScheduleInfo ?
										selectedScheduleInfo.respondedApplications.registered + '/' +
										selectedScheduleInfo.respondedApplications.quota : '--' }}</view>
									<view class="data-label">已报/名额</view>
								</view>
							</view>
						</view>
					</view>
				</view>

				<!-- 待答复的申请区域 -->
				<view v-if="hasPeriodSelected" class="pending-applications-section">
					<view class="section-title-box">
						<FontIcon name="icon-daidafu" class="section-header__icon" size="28rpx" style="color:#ff6b35">
						</FontIcon>
						<text class="section-title-text">待答复的申请</text>
					</view>

					<view class="application-list" v-if="pendingApplications.length > 0">
						<template v-for="(application, index) in pendingApplications" :key="index">
							<view class="application-card">
								<view class="card-header">
									<view class="agency-info">
										<view v-if="application.businessType == 2" class="group-badge">
											<FontIcon name="icon-qizhi" color="#ffffff" />
											<text>组团</text>
										</view>
										<view v-if="application.businessType == 3" class="group-badge-team">
											<FontIcon name="icon-qizhi" color="#ffffff" />
											<text>随队</text>
										</view>
										<text class="agency-name">{{ application.agencyName }}</text>
										<text class="play-icon">▶</text>
									</view>


									<view class="rating">
										<text class="star-icon">★</text>
										<text class="rating-value">{{ application.rating }}</text>
									</view>
								</view>
								<view v-if="application.businessType == 2" class="card-detail-row">
									<text class="detail-label">客源城市</text>
									<text class="detail-value">{{ application.sourceCity }}</text>
								</view>

								<view v-if="application.businessType == 3" class="card-detail-row-team">
									<view>
										<text class="detail-label">客源地点</text>
										<text class="detail-value">{{ application.sourceCity }}</text>
									</view>
									<view
										style="padding: 10rpx 20rpx;background: #FBBD08;border-radius: 5000rpx;display: flex;align-items: center;font-size: 24rpx;">
										<FontIcon name="icon-daohangbiaozhi" class="section-header__icon" size="28rpx">
										</FontIcon>
										<text>地点</text>
									</view>
								</view>
								<view class="card-footer">
									<view class="quota-display">
										<text class="detail-label">申请名额</text>
										<text class="detail-value">{{ application.quota }}</text>
									</view>
									<view
										:class="{ 'reply-button': application.businessType === 2, 'reply-button-team': application.businessType === 3 }"
										@click="replyApplication(application)">答复申请</view>

								</view>
							</view>
							<view v-if="index < pendingApplications.length - 1" class="card-divider-between"></view>
						</template>
					</view>
					<view class="empty-state" v-else>
						<text class="empty-text">暂无待答复的申请</text>
					</view>
				</view>

				<!-- 已答复的申请区域 -->
				<view v-if="hasPeriodSelected" class="responded-applications-section">
					<view class="section-title-box">
						<FontIcon name="icon-yidafu" class="section-header__icon" size="28rpx" style="color:#787878">
						</FontIcon>
						<text class="section-title-text">已答复的申请</text>
					</view>

					<view class="application-list" v-if="respondedApplications.length > 0">
						<template v-for="(application, index) in respondedApplications" :key="index">
							<view class="application-card">
								<view class="card-header">
									<view class="agency-info">
										<view v-if="application.businessType == 2" class="group-badge">
											<FontIcon name="icon-qizhi" color="#ffffff" />
											<text>组团</text>
										</view>
										<view v-if="application.businessType == 3" class="group-badge-team">
											<FontIcon name="icon-qizhi" color="#ffffff" />
											<text>随队</text>
										</view>
										<text class="agency-name">{{ application.agencyName }}</text>
										<text class="play-icon">▶</text>
									</view>
									<view class="rating">
										<text class="star-icon">★</text>
										<text class="rating-value">{{ application.rating }}</text>
									</view>
								</view>
								<view v-if="application.businessType == 2" class="card-detail-row">
									<text class="detail-label">客源城市</text>
									<text class="detail-value">{{ application.sourceCity }}</text>
								</view>

								<view v-if="application.businessType == 3" class="card-detail-row-team">
									<view>
										<text class="detail-label">客源地点</text>
										<text class="detail-value">{{ application.sourceCity }}</text>
									</view>
									<u-icon name="map-fill" size="20" color="#1cbbb4"></u-icon>
								</view>
								<view class="card-footer">
									<view class="quota-display">
										<text class="detail-label">{{ getQuotaLabel() }}</text>
										<text class="detail-value">{{ application.quota }}</text>
									</view>
									<view class="registration-button"
										:style="getRegistrationButtonStyle(application.businessType)"
										@click="viewRegistrationDetails(application)">报名详情
									</view>
								</view>
							</view>
							<view v-if="index < respondedApplications.length - 1" class="card-divider-between"></view>
						</template>
					</view>
					<view class="empty-state" v-else>
						<text class="empty-text">暂无已答复的申请</text>
					</view>
				</view>

				<!-- 已确认成团区域 -->
				<view v-if="hasPeriodSelected" class="confirmed-group-section">
					<view class="section-title-box">
						<FontIcon name="icon-yibaoming" class="section-header__icon" size="28rpx" style="color:#787878">
						</FontIcon>
						<text class="section-title-text">已确认成团</text>
					</view>

					<!-- :style="{border: group.businessType === 2 ? '2rpx solid #39B54A;' : group.businessType === 3 ? '2rpx solid #FBBD08' : '#cccccc'}" -->
					<view class="application-list" v-if="confirmedGroups.length > 0">
						<template v-for="(group, index) in confirmedGroups" :key="index">
							<view class="application-card">
								<view class="card-header">
									<view class="agency-info">
										<view v-if="group.businessType == 2" class="group-badge">
											<FontIcon name="icon-qizhi" color="#ffffff" />
											<text>组团</text>
										</view>
										<view v-if="group.businessType == 3" class="group-badge-team">
											<FontIcon name="icon-qizhi" color="#ffffff" />
											<text>随队</text>
										</view>
										<text class="agency-name">{{ group.agencyName }}</text>
										<text class="play-icon">▶</text>
									</view>
									<view class="rating">
										<text class="star-icon">★</text>
										<text class="rating-value">{{ group.rating }}</text>
									</view>
								</view>
								<view v-if="group.businessType == 2" class="card-detail-row">
									<text class="detail-label">客源城市</text>
									<text class="detail-value">{{ group.sourceCity }}</text>
								</view>

								<view v-if="group.businessType == 3" class="card-detail-row-team">
									<text class="detail-value">{{ group.sourceCity }}</text>
									<u-icon name="map-fill" size="20" color="#1cbbb4"></u-icon>
								</view>
								<view class="card-footer">
									<view class="quota-display">
										<text class="detail-label">{{ getQuotaLabel() }}</text>
										<text class="detail-value">{{ group.quota }}</text>
									</view>
									<view class="registration-button"
										:style="getRegistrationButtonStyle(group.businessType)"
										@click="viewRegistrationDetails(group)">报名详情</view>
								</view>
							</view>
							<view v-if="index < confirmedGroups.length - 1" class="card-divider-between"></view>
						</template>
					</view>
					<view class="empty-state" v-else>
						<text class="empty-text">暂无已确认成团</text>
					</view>

					<view class="info-notice" v-if="confirmedGroups.length > 0">
						<text class="notice-text">已确认成团的团队信息,已同步至[行程管理]、[交易管理]
							请在行程管理页面进行相关操作,订单信息可在小程序-我的-[交易管理]中查看。</text>
					</view>
				</view>
			</view>
		</view>

		<!-- 底部操作栏 -->
		<view class="bottom-action-bar">
			<view class="action-button" @click="goBack">
				<text class="button-text">返回</text>
			</view>
			<view class="action-button" @click="viewShelfDetails">
				<text class="button-text">上架详情</text>
			</view>
			<view class="action-button" @click="viewApplicationRecord">
				<text class="button-text">申请记录</text>
			</view>
		</view>
	</view>
</template>

<script>
import {
	request
} from '@/utils/request.js'
import ProductCard from '@/components/ProductCard.vue'
import DateCard from '@/components/DateCard.vue'
import AdaptiveNavBar from '@/components/AdaptiveNavBar.vue'
import {
	mergeAllProducts
} from '@/utils/productUtil'

export default {
	components: {
		ProductCard,
		DateCard,
		AdaptiveNavBar
	},
	data() {
		return {
			// 加载状态
			loading: false,
			// 状态栏高度
			statusBarHeight: 0,
			// 产品ID
			productId: null,
			// 商品信息
			productInfo: {},
			// 班期数据
			schedules: [],
			// 选中的班期信息
			selectedScheduleInfo: null,
			// 存储每个班期的详细数据
			scheduleData: {},
			// 申请数据
			pendingApplications: [],
			respondedApplications: [],
			confirmedGroups: [],
			// 班期选择相关
			maxDisplayDates: 4, // 默认最多显示4个班期
			selectedScheduleIndex: -1, // 当前选中的班期索引
			// 班期选择相关（用于班期卡片显示）
			selectedDates: [], // 选中的班期日期列表
			selectedPeriodIds: [], // 选中的班期ID列表
			isApplyCall: false, // 是否是申请调用模式
			showAllPeriods: false, // 是否展开所有班期
			maxPeople: 30, // 每团满员人数
			applicationDeadline: 15, // 渠道申请截止天数
			hasPeriodSelected: false, // 是否已选择班期
			// 🔑 getPeriodsFor 接口相关
			isFromGetPeriodsFor: false, // 是否使用了 getPeriodsFor 接口
			periodSource: null, // 当前使用的数据源（p1s/p2s/p3s）
			aStatePeriods: [], // A 状态的班期数据（来自上一级）
			previousSelectedDates: [] // 🔑 保存之前的班期列表（用于对比新选中的班期）
		}
	},

	created() {
		// 页面创建时的初始化逻辑
	},

	onLoad(options) {
		// 🔑 清空 cooperationDateUtilPage 的缓存数据，避免其他班期显示错误数据
		try {
			uni.removeStorageSync('checkedPeriodArr')
			uni.removeStorageSync('selectedDates')
			uni.removeStorageSync('selectedDatesA')
			uni.removeStorageSync('selectedDatesB')
			uni.removeStorageSync('selectedDatesBForPeriodList')
			uni.removeStorageSync('userSelectedPeriodsForB')
			uni.removeStorageSync('existingSelectedDates')
			uni.removeStorageSync('periodSelectParams')
			uni.removeStorageSync('periodList')
			uni.removeStorageSync('outerPeriodList')
			uni.removeStorageSync('bStatePeriodsOriginal')
			console.log('[合作申请管理] onLoad 已清空 cooperationDateUtilPage 的缓存数据')
		} catch (e) {
			console.warn('[合作申请管理] 清空缓存数据失败:', e)
		}
		
		// 获取状态栏高度
		const systemInfo = uni.getSystemInfoSync()
		this.statusBarHeight = systemInfo.statusBarHeight || 20

		// 获取传递的商品ID
		if (options && options.id) {
			console.log('[合作申请管理] onLoad 接收 id:', options.id)
			this.productId = options.id
			// 🔑 先加载产品数据，再加载班期数据（确保 productInfo 已加载）
			this.loadProductData(this.productId).then(() => {
				// 产品数据加载完成后再加载班期数据
				this.loadScheduleData(this.productId)
			}).catch(err => {
				console.error('[合作申请管理] 初始化加载失败:', err)
			})
		} else {
			// 兜底：从当前路由参数获取
			try {
				const pages = getCurrentPages()
				const cur = pages[pages.length - 1]
				const q = (cur && cur.options) || {}
				if (q.id) {
					console.log('[合作申请管理] 路由兜底获取 id:', q.id)
					this.productId = q.id
					// 🔑 先加载产品数据，再加载班期数据（确保 productInfo 已加载）
					this.loadProductData(this.productId).then(() => {
						// 产品数据加载完成后再加载班期数据
						this.loadScheduleData(this.productId)
					}).catch(() => { })
				} else {
					uni.showToast({
						title: '产品ID不存在',
						icon: 'none'
					})
				}
			} catch (e) { }
		}

		// 初始化时加载默认选中的班期信息
		this.initSelectedSchedule()

		// 注意：不在初始化时加载申请数据
		// 申请数据应在用户选中班期后再加载
		// this.loadApplicationData()
	},

	onShow() {
		// 🔑 保存之前的班期列表（用于对比新选中的班期）
		const previousSelectedDates = this.selectedDates && this.selectedDates.length > 0 
			? JSON.parse(JSON.stringify(this.selectedDates)) 
			: []
		
		// 🔑 检查是否从 cooperationDateUtilPage 返回，读取B状态选中的班期数据
		try {
			// 优先读取 checkedPeriodArr（B状态选中的数组）
			const checkedPeriodArr = uni.getStorageSync('checkedPeriodArr')
			if (checkedPeriodArr) {
				console.log('[合作申请管理] onShow 检测到从日期选择页面返回的B状态选中数组')
				const parsedArr = JSON.parse(checkedPeriodArr)
				if (parsedArr && Array.isArray(parsedArr) && parsedArr.length > 0) {
					console.log('[合作申请管理] 使用B状态选中数组更新 selectedDates，数量:', parsedArr.length)
					// 🔑 将 checkedPeriodArr 转换为 selectedDates 格式
					// checkedPeriodArr 中的 fullData 包含完整数据，直接使用
					// 🔑 注意：cooperationDateUtilPage 的选中是多选，用于显示班期列表
					// cooperation.vue 的选中是单选，用于查看某一天的申请详情，两者应该区分开
					const newSelectedDates = parsedArr.map(item => {
						// 如果 fullData 存在，使用 fullData，否则使用 item 本身
						const periodData = item.fullData || item
						return {
							DateName: periodData.DateName || item.DateName,
							WeekName: periodData.WeekName || item.WeekName,
							periodId: periodData.periodId || periodData.id || item.periodId || item.id,
							id: periodData.id || item.id,
							// 🔑 重置 isSelected 为 false，因为这是日期选择页面的多选状态，不应该影响合作申请管理页面的单选状态
							isSelected: false,
							status: periodData.status || item.status,
							isSelectable: periodData.isSelectable !== undefined ? periodData.isSelectable : (periodData.status === 1),
							availableDate: periodData.availableDate || item.availableDate,
							applicationDeadline: periodData.applicationDeadline || item.applicationDeadline,
							// 保留其他字段
							...periodData
						}
					})
					
					// 🔑 对比返回的B状态班期，找出新选中的班期（status=0 的）
					const newSelectedPeriods = newSelectedDates.filter(newPeriod => {
						// 检查是否在之前的列表中
						const existed = previousSelectedDates.some(prevPeriod => {
							const prevPeriodId = prevPeriod.periodId || prevPeriod.id
							const newPeriodId = newPeriod.periodId || newPeriod.id
							return prevPeriodId && newPeriodId && String(prevPeriodId) === String(newPeriodId)
						})
						// 如果之前没有，且 status=0（新申请），则是新选中的
						return !existed && (newPeriod.status === 0 || newPeriod.status === '0')
					})
					
					console.log('[合作申请管理] 对比结果 - 之前的班期数:', previousSelectedDates.length, '返回的班期数:', newSelectedDates.length, '新选中的班期数:', newSelectedPeriods.length)
					
					// 🔑 对班期列表按日期排序
					const sortedNewSelectedDates = this.sortPeriodsByDate(newSelectedDates)
					
					// 更新 selectedDates
					this.selectedDates = sortedNewSelectedDates
					// 清空 storage，避免下次误读
					uni.removeStorageSync('checkedPeriodArr')
					console.log('[合作申请管理] ✅ selectedDates 已使用B状态选中数组更新')
					console.log('[合作申请管理] 更新后的 selectedDates:', this.selectedDates)

					// 🔑 如果是 productType 为 1 或 3 的产品，调用 updatePeriodOdd 接口更新班期
					const productType = Number(this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0)
					if (productType === 1 || productType === 3) {
						console.log('[合作申请管理] productType 为', productType, '，准备调用 updatePeriodOdd 接口更新班期')
						this.updatePeriodOddForProductType1Or3(newSelectedDates)
					} else if (productType === 2 || productType === 4) {
						// 🔑 如果是 productType 为 2 或 4 的产品，调用 updatePeriodEven 接口更新班期
						console.log('[合作申请管理] productType 为', productType, '，准备调用 updatePeriodEven 接口更新班期')
						this.updatePeriodEvenForProductType2Or4(newSelectedDates, previousSelectedDates)
					}
				}
			} else {
				// 兜底：如果没有 checkedPeriodArr，尝试读取 selectedDates
				const savedSelectedDates = uni.getStorageSync('selectedDates')
				if (savedSelectedDates) {
					console.log('[合作申请管理] onShow 检测到从日期选择页面返回的数据（兜底）')
					const parsedDates = JSON.parse(savedSelectedDates)
					if (parsedDates && Array.isArray(parsedDates) && parsedDates.length > 0) {
						console.log('[合作申请管理] 更新 selectedDates，数量:', parsedDates.length)
						// 🔑 重置所有班期的 isSelected 为 false（日期选择页面的多选状态不应该影响合作申请管理页面的单选状态）
						parsedDates.forEach(period => {
							period.isSelected = false
						})
						// 🔑 对班期列表按日期排序
						const sortedParsedDates = this.sortPeriodsByDate(parsedDates)
						
						// 更新 selectedDates 列表
						this.selectedDates = sortedParsedDates
						// 清空 storage，避免下次误读
						uni.removeStorageSync('selectedDates')
						console.log('[合作申请管理] ✅ selectedDates 已更新（兜底）')
						
						// 🔑 恢复合作申请管理页面的选中状态（单选，用于查看申请详情）
						// 尝试找到之前选中的班期（如果存在且可选）
						const previousSelectedPeriod = previousSelectedDates.find(p => p.isSelected)
						if (previousSelectedPeriod) {
							const previousPeriodId = previousSelectedPeriod.periodId || previousSelectedPeriod.id
							const previousDateName = previousSelectedPeriod.DateName
							// 在新返回的班期列表中查找对应的班期
							const matchedPeriod = parsedDates.find(newPeriod => {
								const newPeriodId = newPeriod.periodId || newPeriod.id
								return (previousPeriodId && newPeriodId && String(previousPeriodId) === String(newPeriodId)) ||
									(previousDateName && newPeriod.DateName === previousDateName)
							})
							// 如果找到且可选（status=1），则选中它
							if (matchedPeriod && matchedPeriod.status === 1) {
								matchedPeriod.isSelected = true
								this.selectedPeriodIds = [matchedPeriod.periodId || matchedPeriod.id]
								this.updateSelectedScheduleInfoByPeriod(matchedPeriod)
								this.hasPeriodSelected = true
								console.log('[合作申请管理] ✅ 恢复之前选中的班期（兜底）:', matchedPeriod.DateName)
							} else {
								// 如果找不到或不可选，尝试选中第一个可选的班期
								const firstSelectablePeriod = parsedDates.find(p => p.status === 1)
								if (firstSelectablePeriod) {
									firstSelectablePeriod.isSelected = true
									this.selectedPeriodIds = [firstSelectablePeriod.periodId || firstSelectablePeriod.id]
									this.updateSelectedScheduleInfoByPeriod(firstSelectablePeriod)
									this.hasPeriodSelected = true
									console.log('[合作申请管理] ✅ 默认选中第一个可选班期（兜底）:', firstSelectablePeriod.DateName)
								} else {
									// 没有可选的班期，清空选中状态
									this.selectedPeriodIds = []
									this.selectedScheduleInfo = null
									this.hasPeriodSelected = false
									console.log('[合作申请管理] ⚠️ 没有可选的班期（兜底），清空选中状态')
								}
							}
						} else {
							// 之前没有选中的班期，尝试选中第一个可选的班期
							const firstSelectablePeriod = parsedDates.find(p => p.status === 1)
							if (firstSelectablePeriod) {
								firstSelectablePeriod.isSelected = true
								this.selectedPeriodIds = [firstSelectablePeriod.periodId || firstSelectablePeriod.id]
								this.updateSelectedScheduleInfoByPeriod(firstSelectablePeriod)
								this.hasPeriodSelected = true
								console.log('[合作申请管理] ✅ 默认选中第一个可选班期（兜底）:', firstSelectablePeriod.DateName)
							} else {
								// 没有可选的班期，清空选中状态
								this.selectedPeriodIds = []
								this.selectedScheduleInfo = null
								this.hasPeriodSelected = false
								console.log('[合作申请管理] ⚠️ 没有可选的班期（兜底），清空选中状态')
							}
						}
					}
					
					// 🔑 如果是 productType 为 1 或 3 的产品，调用 updatePeriodOdd 接口更新班期（兜底逻辑）
					const productType = Number(this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0)
					if (productType === 1 || productType === 3) {
						console.log('[合作申请管理] productType 为', productType, '，准备调用 updatePeriodOdd 接口更新班期（兜底）')
						this.updatePeriodOddForProductType1Or3(parsedDates)
					} else if (productType === 2 || productType === 4) {
						// 🔑 如果是 productType 为 2 或 4 的产品，调用 updatePeriodEven 接口更新班期（兜底逻辑）
						console.log('[合作申请管理] productType 为', productType, '，准备调用 updatePeriodEven 接口更新班期（兜底）')
						this.updatePeriodEvenForProductType2Or4(parsedDates, previousSelectedDates)
					}
				}
			}
		} catch (e) {
			console.error('[合作申请管理] 读取班期数据失败:', e)
		}

		// 补偿触发：若进入时网络未完成或被打断，这里再次尝试
		if (this.productId) {
			console.log('[合作申请管理] onShow 触发刷新, id:', this.productId)
			if (!this.productInfo || !this.productInfo.mainInfo) {
				this.loadProductData(this.productId)
			}
			if (!this.schedules || this.schedules.length === 0) {
				this.loadScheduleData(this.productId)
			}

			// 检查是否有选中的班期
			const hasSelectedPeriod = this.selectedDates && this.selectedDates.some(item => item.isSelected)
			this.hasPeriodSelected = hasSelectedPeriod

			// 只有选中班期后才加载该班期的申请数据
			if (hasSelectedPeriod) {
				// 获取选中的班期
				const selectedPeriod = this.selectedDates.find(item => item.isSelected)
				if (selectedPeriod && selectedPeriod.periodId) {
					// 构建完整的日期显示
					const dateParts = selectedPeriod.DateName ? selectedPeriod.DateName.split('-') : []
					const fullDate = dateParts.length >= 3 ?
						`${dateParts[0]}年${dateParts[1]}月${dateParts[2]}日` :
						(selectedPeriod.DateName || '--')
					// 根据班期ID加载该班期的申请数据
					this.loadPeriodApplications(selectedPeriod.periodId, fullDate)
				}
			} else {
				// 如果没有选中班期，清空相关数据
				this.selectedScheduleInfo = null
				this.pendingApplications = []
				this.respondedApplications = []
				this.confirmedGroups = []
			}
		}
	},

	computed: {
		// 导航栏总高度（rpx）
		navbarTotalHeightRpx() {
			if (this.$navbarUtil && this.$navbarUtil.getNavbarTotalHeightRpx) {
				return this.$navbarUtil.getNavbarTotalHeightRpx()
			}
			// 如果 $navbarUtil 不可用，返回默认值
			return '176rpx' // 默认 88px * 2 = 176rpx
		},
		// 显示的班期列表（限制数量）
		displaySchedules() {
			return this.schedules.slice(0, this.maxDisplayDates);
		},
		// 选中班期价格的整数/小数拆分（固定两位小数）
		selectedPriceParts() {
			const selectedPeriod = this.selectedDates && this.selectedDates.find(item => item.isSelected)
			const price = selectedPeriod && selectedPeriod.periodData && selectedPeriod.periodData.price ? selectedPeriod.periodData.price : 0
			const val = Number(price) || 0
			const str = val.toFixed(2)
			const parts = str.split('.')
			return { intPart: parts[0], decPart: parts[1] || '00' }
		}
	},

	methods: {
		goBack() {
			uni.navigateBack()
		},

		selectSchedule(index) {
			// 取消所有选中状态
			this.schedules.forEach(schedule => schedule.selected = false)
			// 选中当前项
			this.schedules[index].selected = true
			// 更新选中索引
			this.selectedScheduleIndex = index

			// 更新已选班期信息
			this.updateSelectedScheduleInfo(index)
		},

		// 班期选择变更（DateCard 组件回调）
		onScheduleChange(selectedSchedule) {
			console.log('选择的班期:', selectedSchedule)
			// 找到选中班期的索引
			const index = this.schedules.findIndex(schedule => schedule.date === selectedSchedule.date)
			if (index !== -1) {
				this.selectSchedule(index)
			}
		},

		// 显示全部班期
		showAllSchedules() {
			// 这里可以显示弹出层或跳转到班期列表页面
			uni.showToast({
				title: '显示全部班期',
				icon: 'none'
			})
		},

		// 🔑 将原始班期数据转换为 dateUtilPage 需要的格式（模仿 periodCreate.vue 的格式）
		convertPeriodsToDateFormat(periodArray) {
			if (!periodArray || !Array.isArray(periodArray) || periodArray.length === 0) {
				console.log('⚠️ convertPeriodsToDateFormat: 输入数据为空或不是数组')
				return []
			}
			
			console.log('📋 convertPeriodsToDateFormat: 开始转换，输入数据数量:', periodArray.length)
			
			// 🔑 模仿 periodCreate.vue 中的格式转换逻辑
			const result = periodArray.map((period, index) => {
				// 检查 availableDate 是否存在
				if (!period.availableDate) {
					console.warn(`⚠️ convertPeriodsToDateFormat: 第 ${index + 1} 个班期缺少 availableDate:`, period)
					return null
				}
				
				const { yearDate, monthDate, dayDate, weekDate } = period.availableDate
				
				// 🔑 确保 monthDate 和 dayDate 是字符串，并补齐前导零
				const monthStr = monthDate ? String(monthDate).padStart(2, '0') : ''
				const dayStr = dayDate ? String(dayDate).padStart(2, '0') : ''
				
				// 构建日期字符串（格式：YYYY-MM-DD）
				const dateStr = yearDate && monthStr && dayStr 
					? `${yearDate}-${monthStr}-${dayStr}` 
					: ''
				
				// 🔑 如果日期不完整，打印警告并返回 null
				if (!dateStr) {
					console.warn(`⚠️ convertPeriodsToDateFormat: 第 ${index + 1} 个班期日期不完整:`, {
						id: period.id,
						yearDate,
						monthDate,
						dayDate,
						availableDate: period.availableDate
					})
					return null
				}
				
				// 🔑 模仿 periodCreate.vue 的格式：只包含 DateName, WeekName, periodId, isSelected
				// 注意：periodCreate.vue 中 A 状态（outerPeriodList）不包含 periodData
				return {
					DateName: dateStr,
					WeekName: weekDate || period.weekName || '—',
					periodId: period.id || period.periodId || null,
					isSelected: false // A状态默认不选中
				}
			}).filter(item => item !== null) // 过滤掉 null 项
			
			console.log('📋 convertPeriodsToDateFormat: 转换完成，有效数据数量:', result.length)
			return result
		},

		// 选择日期（跳转到日期选择页面）
		chooseDate() {
			// 获取商家类型和产品类型
			const companyInfo = uni.getStorageSync('companyInfo') || {}
			const businessType = companyInfo.businessType || 1
			const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0

			console.log('跳转班期管理 - businessType:', businessType, 'productType:', productType, 'isFromGetPeriodsFor:', this.isFromGetPeriodsFor)

			// 🔑 将当前显示的班期列表（selectedDates），保存到storage，供日期选择页面读取
			// 这个数据将作为 cooperationDateUtilPage 的初始 B 状态数据（所有显示的班期都作为 B 状态）
			if (this.selectedDates && this.selectedDates.length > 0) {
				console.log('📋 保存 cooperation.vue 中显示的班期列表（将作为 B 状态的初始值）:', this.selectedDates);
				// 保存所有班期数据（包含选中状态）
				uni.setStorageSync('existingSelectedDates', JSON.stringify(this.selectedDates));
				// 🔑 将 cooperation.vue 中显示的所有班期列表（selectedDates）作为 B 状态的初始值
				// 注意：这里传递的是所有显示的班期，不管 isSelected 是否为 true
				uni.setStorageSync('userSelectedPeriodsForB', JSON.stringify(this.selectedDates));
				console.log('📋 cooperation.vue 中显示的班期数量（B状态初始值）:', this.selectedDates.length);
			}

			// 🔑 如果使用了 getPeriodsFor 接口，设置为 B 模式
			if (this.isFromGetPeriodsFor) {
				console.log('📋 使用了 getPeriodsFor 接口，设置为 B 模式')
				console.log('📋 A状态班期数据（原始）:', this.aStatePeriods)
				console.log('📋 B状态班期数据（当前）:', this.selectedDates)
				
				// 将 A 状态的原始数据转换为 dateUtilPage 需要的格式
				const aStatePeriodList = this.convertPeriodsToDateFormat(this.aStatePeriods)
				// B 状态使用当前选中的班期（已选中的）
				const bStatePeriodList = this.selectedDates.filter(item => item.isSelected) || []
				
				// 🔑 打印 A 状态原始数据
				console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
				console.log('📋 A 状态原始数据（this.aStatePeriods）:')
				console.log('   总数:', this.aStatePeriods.length, '个班期')
				if (this.aStatePeriods.length > 0) {
					this.aStatePeriods.forEach((period, index) => {
						const ad = period.availableDate || {}
						console.log(`   [${index + 1}] 原始数据:`, {
							id: period.id,
							availableDate: ad,
							year: ad.yearDate ?? ad.year ?? '',
							month: ad.monthDate ?? ad.month ?? '',
							day: ad.dayDate ?? ad.day ?? '',
							weekDate: ad.weekDate || period.weekName || '—'
						})
					})
				}
				console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
				
				// 🔑 打印 A 状态列表详细信息
				console.log('📋 A 状态班期列表（转换后 - outerPeriodList）:')
				console.log('   总数:', aStatePeriodList.length, '个班期')
				if (aStatePeriodList.length > 0) {
					aStatePeriodList.forEach((period, index) => {
						console.log(`   [${index + 1}]`, {
							DateName: period.DateName,
							WeekName: period.WeekName,
							periodId: period.periodId,
							isSelected: period.isSelected,
							periodData: period.periodData
						})
					})
				} else {
					console.log('   ⚠️ A 状态列表为空')
				}
				console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
				
				// 🔑 打印 B 状态列表详细信息
				console.log('📋 B 状态班期列表（periodList）:')
				console.log('   总数:', bStatePeriodList.length, '个班期')
				if (bStatePeriodList.length > 0) {
					bStatePeriodList.forEach((period, index) => {
						console.log(`   [${index + 1}]`, {
							DateName: period.DateName,
							WeekName: period.WeekName,
							periodId: period.periodId,
							isSelected: period.isSelected,
							status: period.status,
							isSelectable: period.isSelectable
						})
					})
				} else {
					console.log('   ⚠️ B 状态列表为空')
				}
				console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
				
				// 传递必要参数到 dateUtilPage（设置为 B 模式）
				uni.setStorageSync('periodSelectParams', JSON.stringify({
					businessType: businessType,
					isApplyCall: true, // 🔑 设置为申请调用模式
					applicationDeadline: this.applicationDeadline,
					productId: this.productId,
					productType: productType,
					allowEdit: true, // 从合作申请管理页面进入，允许编辑日期
					isBMode: true // 🔑 明确设置为 B 模式
				}));

				// A 状态作为外层班期列表（outerPeriodList）
				uni.setStorageSync('outerPeriodList', JSON.stringify(aStatePeriodList))
				// B 状态作为当前班期列表（periodList）
				uni.setStorageSync('periodList', JSON.stringify(bStatePeriodList))
				// 🔑 保存 getPeriodsFor 接口返回的 B 状态原始数据（用于后续对比）
				if (this.bStatePeriods && this.bStatePeriods.length > 0) {
					uni.setStorageSync('bStatePeriodsOriginal', JSON.stringify(this.bStatePeriods))
					console.log('📋 保存 getPeriodsFor 接口返回的 B 状态原始数据:', this.bStatePeriods.length, '个班期')
				}
				
				console.log('✅ 已保存到 storage:')
				console.log('   - outerPeriodList:', aStatePeriodList.length, '个班期')
				console.log('   - periodList:', bStatePeriodList.length, '个班期')
			} else {
				// 传递必要参数到 dateUtilPage
				uni.setStorageSync('periodSelectParams', JSON.stringify({
					businessType: businessType,
					isApplyCall: this.isApplyCall,
					applicationDeadline: this.applicationDeadline,
					productId: this.productId,
					productType: productType,
					allowEdit: true // 从合作申请管理页面进入，允许编辑日期
				}));

				// 根据业务类型和产品类型判断如何传递班期数据
				// 一类商家的泛营期设置（businessType=1, productType=1）
				// 二类商家的综合研学（businessType=2, productType=2）与目的地接待（businessType=2, productType=3）
				// -> 所有营期直接显示为A状态，没有B状态
				if ((businessType === 1 && productType === 1) ||
					(businessType === 2 && (productType === 2 || productType === 3))) {
					// 传递所有班期作为A状态
					const periodList = this.selectedDates || []
					uni.setStorageSync('periodList', JSON.stringify(periodList))
					console.log('传递班期列表（A状态）:', periodList)
				}
				// 二类的组团业务（businessType=2, productType=4）
				// 三类的研学活动（businessType=3, productType=5）
				// -> 营期列表显示的日期为A状态，选中的为B状态
				else if ((businessType === 2 && productType === 4) ||
					(businessType === 3 && productType === 5)) {
					// 所有班期作为A状态（外层班期列表）
					const outerPeriodList = this.selectedDates || []
					// 选中的班期作为B状态（当前班期列表）
					const currentPeriodList = this.selectedDates.filter(item => item.isSelected) || []

					uni.setStorageSync('outerPeriodList', JSON.stringify(outerPeriodList))
					uni.setStorageSync('periodList', JSON.stringify(currentPeriodList))
					console.log('传递外层班期列表（A状态）:', outerPeriodList)
					console.log('传递当前班期列表（B状态）:', currentPeriodList)
				}
				// 其他情况：默认传递所有班期作为A状态
				else {
					const periodList = this.selectedDates || []
					uni.setStorageSync('periodList', JSON.stringify(periodList))
					console.log('默认传递班期列表（A状态）:', periodList)
				}
			}

			// 跳转到日期选择页面（使用专门为 cooperation 页面创建的日期选择页面）
			uni.navigateTo({
				url: '/public/cooperation/cooperationDateUtilPage'
			});
		},

		// 判断班期是否可选（基于当前时间 + 渠道申请截止天数）- 接受日期字符串和截止天数
		isPeriodSelectableByDate(dateStr, deadlineDays) {
			if (!dateStr) {
				return false
			}
			console.log('看看班期的每个值', dateStr)
			// 获取当前时间
			const now = new Date()
			// 使用传入的截止天数，如果没有则使用默认值 60
			const deadline = deadlineDays || 60

			// 计算截止时间：当前时间 + 渠道申请截止天数
			const deadlineTime = new Date(now)
			deadlineTime.setDate(now.getDate() + deadline)

			// 解析班期日期
			const periodDate = new Date(dateStr)
			// 设置时间为当天 0:0:0，只比较日期
			periodDate.setHours(0, 0, 0, 0)
			deadlineTime.setHours(0, 0, 0, 0)

			// 如果班期日期在截止时间之前（或等于），则不可选
			// 如果班期日期在截止时间之后，则可选
			return periodDate > deadlineTime
		},

		// 判断班期是否可选（基于当前时间 + 渠道申请截止天数）- 接受班期对象
		// 注意：此方法仅用于样式判断，不影响点击功能
		isPeriodSelectable(periodItem) {
			if (!periodItem || !periodItem.DateName) {
				return false
			}
			
			// 🔑 如果班期来自 getPeriodsFor 接口，根据 status 判断是否可选
			// status: 0-申请中(不可选), 1-已同意(可选), 2-已拒绝(不可选)
			if (periodItem.status !== undefined && periodItem.status !== null) {
				const status = Number(periodItem.status)
				// status=1 可选，status=0 或 2 不可选
				return status === 1
			}
			
			// 其他情况：保留 applicationDeadline 限制用于样式显示
			// 从班期的 periodData 中获取 applicationDeadline
			const deadlineDays = periodItem.periodData?.applicationDeadline || this.applicationDeadline || 60
			return this.isPeriodSelectableByDate(periodItem.DateName, deadlineDays)
		},
		
		// 🔑 获取班期状态文本
		getPeriodStatusText(periodItem) {
			if (periodItem.status === undefined || periodItem.status === null) {
				return ''
			}
			const status = Number(periodItem.status)
			if (status === 0) {
				return '待答复' // 🔑 status=0 显示绿色的"待答复"
			} else if (status === 5) {
				return '被驳回' // 🔑 status=2 显示红色的"被驳回"
			}
			return ''
		},

		// 格式化月日显示
		formatMonthDay(dateString) {
			if (!dateString) return ''
			const parts = dateString.split('-')
			if (parts.length >= 3) {
				return `${parts[1]}/${parts[2]}`
			}
			return dateString
		},

		// 获取班期角标数值（优先显示 appendingGroups，为0时显示 repliedGroups）
		getPeriodBadgeValue(periodItem) {
			console.log('')
			if (!periodItem) return 0
			const appending = periodItem.appendingGroups || 0
			const replied = periodItem.repliedGroups || 0
			// 优先显示 appendingGroups
			if (appending > 0) {
				return appending
			}
			// appendingGroups 为0时显示 repliedGroups
			if (replied > 0) {
				return replied
			}
			// 都为0则不显示
			return 0
		},

		// 获取班期角标样式类
		getPeriodBadgeClass(periodItem) {
			if (!periodItem) return 'badge-replied'
			const appending = periodItem.appendingGroups || 0
			const replied = periodItem.repliedGroups || 0
			// 如果 appendingGroups > 0，显示红色
			if (appending > 0) {
				return 'badge-replied'
			}
			// 如果 repliedGroups > 0，显示绿色
			if (replied > 0) {
				return 'badge-pending'
			}
			// 默认返回红色
			return 'badge-replied'
		},

		// 处理班期选择
		handlePeriodSelect(periodItem) {
			if (!periodItem || !periodItem.DateName) {
				console.log('❌ 班期数据无效')
				return
			}
			
			// 🔑 如果班期来自 getPeriodsFor 接口，根据 status 判断是否可选
			// status: 0-申请中(不可选), 1-已同意(可选), 2-已拒绝(不可选)
			if (periodItem.status !== undefined && periodItem.status !== null) {
				const status = Number(periodItem.status)
				if (status !== 1) {
					console.log('❌ 班期状态不可选，status:', status, status === 0 ? '(申请中)' : '(已拒绝)')
					return
				}
			}

			// 检查日期是否已过期（落后于当前时间）
			const periodDate = new Date(periodItem.DateName)
			const today = new Date()
			today.setHours(0, 0, 0, 0)
			periodDate.setHours(0, 0, 0, 0)

			// 如果日期已过期（落后于当前时间），不可点击
			if (periodDate < today) {
				console.log('❌ 日期已过期，不可选择')
				return
			}

			// 日期还没到（未来日期）或者刚好今天，可以点击

			// 使用多种方式查找匹配的班期
			let index = -1

			// 方法1：使用periodId匹配
			if (periodItem.periodId) {
				index = this.selectedDates.findIndex(item => item.periodId === periodItem.periodId)
			}

			// 方法2：使用原始索引匹配
			if (index === -1 && periodItem.originalIndex !== undefined) {
				index = this.selectedDates.findIndex(item => item.originalIndex === periodItem.originalIndex)
			}

			// 方法3：使用日期匹配
			if (index === -1) {
				index = this.selectedDates.findIndex(item => item.DateName === periodItem.DateName)
			}

			if (index !== -1) {
				// 切换选中状态
				const newSelectedState = !this.selectedDates[index].isSelected

				// 单选模式：只能选择一个班期
				if (newSelectedState) {
					// 取消其他所有班期的选中状态
					this.selectedDates.forEach(item => {
						item.isSelected = false
					})
					this.selectedPeriodIds = []
				}

				// 直接修改属性
				this.selectedDates[index].isSelected = newSelectedState

				// 同步更新选中的班期ID列表
				if (newSelectedState) {
					// 单选模式：只保留当前选中的班期ID
					this.selectedPeriodIds = [periodItem.periodId]
					// 更新已选班期信息
					this.updateSelectedScheduleInfoByPeriod(periodItem)
					// 标记已选择班期
					this.hasPeriodSelected = true
				} else {
					// 取消选中时，清空选中列表
					this.selectedPeriodIds = []
					// 清空已选班期信息
					this.selectedScheduleInfo = null
					// 取消选择班期标记
					this.hasPeriodSelected = false
				}

				// 强制触发视图更新
				this.$forceUpdate()

				console.log('✅ 班期选择状态已更新（单选模式）:', {
					periodId: periodItem.periodId,
					dateName: periodItem.DateName,
					isSelected: newSelectedState,
					selectedPeriodIds: this.selectedPeriodIds
				})
			}
		},


		// 获取商品
		async loadProductData(productId) {
			try {
				const companyInfo = uni.getStorageSync('companyInfo') || {}
				const merchantType = companyInfo.businessType || ''
				const res = await request({
					url: `/product-spu/getProductOdd?id=${productId}&merchantType=${merchantType}`,
					method: 'GET'
				})

				if (res.code === 200) {
					console.log('res.data看看返回的参数数据',res.data)
					const d = res.data
					const p1 = d.p1 || {}
					const p2 = d.p2 || {}
					const p3 = d.p3 || {}

					// 🔑 根据 productType 判断使用 p1、p2 还是 p3
					// productType=1（泛营地接待）或 productType=3（目的地接待）-> 使用 p1
					// productType=2（综合研学业务）或 productType=4（组团业务）-> 使用 p2
					// productType=5（研学活动）-> 使用 p3
					const productType = p2?.productSpu?.productType || p1?.productSpu?.productType || p3?.productSpu?.productType
					let mainData, mainSource

					if (productType == 1 || productType == 3) {
						// 使用 p1 数据
						mainData = p1
						mainSource = 'p1'
						console.log('📌 产品类型:', productType, '- 使用 p1 数据')
					} else if (productType == 2 || productType == 4) {
						// 使用 p2 数据
						mainData = p2
						mainSource = 'p2'
						console.log('📌 产品类型:', productType, '- 使用 p2 数据')
					} else if (productType == 5) {
						// 使用 p3 数据
						mainData = p3
						mainSource = 'p3'
						console.log('📌 产品类型:', productType, '- 使用 p3 数据')
					} else {
						// 兜底：优先使用 p1
						mainData = p1 && p1.productSpu ? p1 : (p2 && p2.productSpu ? p2 : p3)
						mainSource = (p1 && p1.productSpu) ? 'p1' : ((p2 && p2.productSpu) ? 'p2' : 'p3')
						console.log('⚠️ 未识别的产品类型:', productType, '- 使用兜底逻辑:', mainSource)
					}

					// 🔑 安全检查：如果根据 productType 选择的数据源是 null，使用兜底逻辑
					if (!mainData || !mainData.productSpu) {
						console.warn('⚠️ 根据productType选择的数据源为null，使用兜底逻辑', {
							productType,
							mainSource,
							p1: !!p1,
							p2: !!p2,
							p3: !!p3
						})

						if (p1 && p1.productSpu) {
							mainData = p1
							mainSource = 'p1'
						} else if (p2 && p2.productSpu) {
							mainData = p2
							mainSource = 'p2'
						} else if (p3 && p3.productSpu) {
							mainData = p3
							mainSource = 'p3'
						} else {
							uni.showToast({
								title: '无有效产品数据',
								icon: 'none'
							})
							return
						}
					}

					const productSpu = mainData.productSpu || d.productSpu || d.mainInfo?.productSpu || {}
					const productSku = mainData.productSku || d.productSku || d.mainInfo?.productSku || {}

					// 圖片字段兼容：string | {url} | {imgUrl}
					let firstImg = '/static/6.jpg'
					if (Array.isArray(productSku.images) && productSku.images.length > 0) {
						const img0 = productSku.images[0]
						firstImg = (typeof img0 === 'string') ? img0 : (img0.url || img0.imgUrl || productSpu.mainImage || '/static/6.jpg')
					} else if (productSpu.mainImage) {
						firstImg = productSpu.mainImage
					}

					// 組裝年齡/天數/地點
					const ageRange = (productSku.minYearOld != null && productSku.maxYearOld != null) ?
						`${productSku.minYearOld}-${productSku.maxYearOld}岁` :
						(productSku.ageRange || productSku.fitAge || '—')
					const duration = productSku.duration || productSku.days || (Array.isArray(productSku.specificItinerary) && productSku.specificItinerary.length > 0 ?
						`${productSku.specificItinerary.length}日` : '—')
					const location = productSpu.cityName || productSpu.address || productSpu.city || '—'

					// 使用 mergeAllProducts 合并完整的产品信息
					console.log('[d], merchantType',[d], merchantType)
					const mergedProductInfo = mergeAllProducts([d], merchantType)

					// 如果 mergeAllProducts 返回有效数据，使用它；否则使用手动构建的数据
					if (mergedProductInfo && mergedProductInfo.length > 0 && mergedProductInfo[0].mainInfo) {
						this.productInfo = mergedProductInfo[0]
						console.log('✅ 产品信息加载成功（使用 mergeAllProducts）:', mergedProductInfo[0])
					} else {
						// 兜底：使用手动构建的数据结构
						this.productInfo = {
							mainInfo: {
								productSpu,
								productSku,
								source: mainSource,
								sourceType: mainSource
							},
							title: productSku.title || productSpu.name || '—',
							image: firstImg,
							details: {
								ageRange,
								duration,
								location
							},
							tag: productSpu.tag || '—',
							price: {
								label: '渠道',
								value: (productSku.channelPrice != null) ?
									`¥${Number(productSku.channelPrice).toFixed(2)}` : (productSpu.price != null) ?
										`¥${Number(productSpu.price).toFixed(2)}` : (d.totalPrice != null ?
											`¥${Number(d.totalPrice).toFixed(2)}` : '—')
							},
							productType: productType, // 保存产品类型
							mainSource: mainSource // 保存数据源
						}
						console.log('✅ 产品信息加载成功（使用手动构建）:', this.productInfo)
					}
				} else {
					uni.showToast({
						title: res?.message || '商品加载失败',
						icon: 'none'
					})
				}
			} catch (error) {
				console.error('加载商品数据失败:', error)
				uni.showToast({
					title: '加载失败',
					icon: 'none'
				})
			}
		},

		// 获取班期数据
		async loadScheduleData(productId) {
			try {
				// 🔑 获取 productType，判断是否需要调用 getMyProductPeriods 接口
				// 等待 productInfo 加载完成（如果还没有加载）
				if (!this.productInfo || !this.productInfo.mainInfo) {
					console.log('⏳ productInfo 尚未加载，等待加载完成...')
					await this.loadProductData(productId)
				}
				
				const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0
				const productTypeNum = Number(productType) || 0
				
				console.log('📋 loadScheduleData - 当前 productType:', productTypeNum, 'productInfo:', this.productInfo)
				
				// 如果 productType=4 或 5，使用 getMyProductPeriods 接口
				if (productTypeNum === 4 || productTypeNum === 5) {
					console.log('📋 productType=', productTypeNum, '，使用 getMyProductPeriods 接口获取班期')
					const periodResult = await this.getMyProductPeriods(productId)
					
					console.log('📋 getMyProductPeriods 返回数据:', periodResult)
					
					if (periodResult && periodResult.bStatePeriods && Array.isArray(periodResult.bStatePeriods) && periodResult.bStatePeriods.length > 0) {
						// 🔑 保存 A 状态数据和数据源信息
						this.isFromGetPeriodsFor = true
						this.periodSource = periodResult.periodSource
						// 🔑 保存 A 状态的原始数据（用于传递给 dateUtilPage）
						this.aStatePeriods = periodResult.aStatePeriods || []
						// 🔑 保存 B 状态的原始数据（getPeriodsFor 接口返回的原始数据，用于后续对比）
						this.bStatePeriods = periodResult.bStatePeriods || []
						
						// 处理返回的班期数据（B 状态）
						console.log('✅ 使用 getMyProductPeriods 返回的班期数据')
						this.processPeriodData(periodResult.bStatePeriods)
						
						// 🔑 打印当前产品的 productType
						console.log('📋 当前产品的 productType:', productTypeNum, '(原始值:', productType, ')')
						console.log('📋 数据源:', periodResult.periodSource, 'A状态班期数:', this.aStatePeriods.length, 'B状态班期数:', periodResult.bStatePeriods.length)
						return
					} else {
						console.warn('⚠️ getMyProductPeriods 返回空数据，使用默认接口')
						this.isFromGetPeriodsFor = false
						this.periodSource = null
						this.aStatePeriods = []
					}
				} else {
					console.log('📋 productType=', productTypeNum, '，使用默认 getPeriods 接口')
					this.isFromGetPeriodsFor = false
					this.periodSource = null
					this.aStatePeriods = []
				}
				
				// 其他情况或 getMyProductPeriods 返回空时，使用默认接口
				const companyInfo = uni.getStorageSync('companyInfo') || {}
				const res = await request({
					url: `/period-sku/getPeriods?spuId=${productId}&merchantId=${companyInfo.id || ''}&merchantType=${companyInfo.businessType || ''}`,
					method: 'GET'
				})
				if (res && (res.code === 200 || res.code === 1) && Array.isArray(res.data)) {
					const schedules = []
					let saleArea = ''
					let saleMode = ''
					console.log('班期数据:', res.data)

					res.data.forEach((group) => {
						// 🔑 根据产品类型选择对应的班期数据源
						// 优先级: p3s > p2s > p1s
						let periodArray = []
						let periodSource = ''

						if (Array.isArray(group.p3s) && group.p3s.length > 0) {
							// 研学活动 (productType=5) 使用 p3s
							periodArray = group.p3s
							periodSource = 'p3s'
						} else if (Array.isArray(group.p2s) && group.p2s.length > 0) {
							// 综合研学业务 (productType=2) 和组团业务 (productType=4) 使用 p2s
							periodArray = group.p2s
							periodSource = 'p2s'
						} else if (Array.isArray(group.p1s) && group.p1s.length > 0) {
							// 泛营地接待 (productType=1) 和目的地接待 (productType=3) 使用 p1s
							periodArray = group.p1s
							periodSource = 'p1s'
						}

						console.log(`📅 使用班期数据源: ${periodSource}, 数量: ${periodArray.length}`)

						periodArray.forEach((it) => {
							// 提取 saleArea 和 saleMode 字段
							if (it.saleArea && !saleArea) {
								saleArea = it.saleArea
							}
							if (it.saleMode && !saleMode) {
								saleMode = it.saleMode
							}

							const ad = it.availableDate || {}
							const year = ad.yearDate ?? ad.year ?? ''
							const monthNum = ad.monthDate ?? ad.month ?? ''
							const dayNum = ad.dayDate ?? ad.day ?? ''
							const mm = monthNum !== '' ? String(monthNum).padStart(2, '0') : ''
							const dd = dayNum !== '' ? String(dayNum).padStart(2, '0') : ''
							const count = Number(it.fullNumberOfRegiment ?? it.groupCount ?? it
								.applyQuota ?? it.quota ?? 0)
							schedules.push({
								date: mm && dd ? `${mm}-${dd}` : '--',
								Datevalue1: mm && dd ? `${mm}-${dd}` :
									'--', // DateCard 组件需要
								WeekName: ad.weekDate || it.weekName ||
									'—', // DateCard 组件需要
								year,
								month: mm,
								day: dd,
								dayLabel: ad.weekDate || it.weekName || '—',
								count,
								badgeType: count > 5 ? 'green' : 'red',
								selected: false,
								periodId: it.id || it.periodId || null, // 保存班期ID
								periodSource: periodSource, // 保存班期数据源
								applicationDeadline: it.applicationDeadline || null, // 保存每个班期的申请截止天数
								appendingGroups: it.appendingGroups || 0, // 待答复申请数
								repliedGroups: it.repliedGroups || 0 // 已答复申请数
							})
						})
					})

					// 更新 productInfo 中的 saleArea 和 saleMode
					if (saleArea || saleMode) {
						if (this.productInfo && this.productInfo.mainInfo) {
							if (!this.productInfo.mainInfo.productSku) {
								this.productInfo.mainInfo.productSku = {}
							}
							this.productInfo.mainInfo.productSku.saleArea = saleArea || '--'
							this.productInfo.mainInfo.productSku.saleMode = saleMode || '--'
						}
					}

					this.schedules = schedules
					console.log(`✅ 共加载 ${schedules.length} 个班期`)

					// 将班期数据转换为 selectedDates 格式（用于班期卡片显示）
					if (schedules.length > 0) {
						const selectedDatesFromSchedules = schedules.map((schedule, index) => {
							// 构建完整的日期字符串
							const dateStr = schedule.year && schedule.month && schedule.day ?
								`${schedule.year}-${schedule.month}-${schedule.day}` :
								(schedule.date ? `2024-${schedule.date}` : '')

							return {
								DateName: dateStr,
								WeekName: schedule.WeekName || schedule.dayLabel || '—',
								periodId: schedule.periodId || `period_${index}_${Date.now()}`,
								isSelected: false, // 不默认选中
								originalIndex: index,
								appendingGroups: schedule.appendingGroups || 0, // 待答复申请数
								repliedGroups: schedule.repliedGroups || 0, // 已答复申请数
								periodData: {
									price: 0, // 可以从后端数据中获取
									leastNumberOfPeople: 20,
									fullNumberOfPeople: 30,
									inventory: schedule.count || 0,
									saleArea: saleArea || '--',
									applicationDeadline: schedule.applicationDeadline || this.applicationDeadline || 15 // 优先使用接口返回的每个班期的applicationDeadline
								}
							}
						})

						// 🔑 对班期列表按日期排序
						const sortedSelectedDatesFromSchedules = this.sortPeriodsByDate(selectedDatesFromSchedules)
						
						// 如果 selectedDates 为空或需要更新，则使用新的数据
						if (!this.selectedDates || this.selectedDates.length === 0) {
							this.selectedDates = sortedSelectedDatesFromSchedules
						} else {
							// 合并数据，保留已有的选中状态
							sortedSelectedDatesFromSchedules.forEach(newItem => {
								const existingItem = this.selectedDates.find(item =>
									item.periodId === newItem.periodId ||
									item.DateName === newItem.DateName
								)
								if (existingItem) {
									// 保留已有的选中状态
									newItem.isSelected = existingItem.isSelected
								}
							})
							this.selectedDates = sortedSelectedDatesFromSchedules
						}

					// 默认选中第一个班期（首次进入时）
					let selectedIds = this.selectedDates
						.filter(item => item.isSelected)
						.map(item => item.periodId)

					if (selectedIds.length === 0 && this.selectedDates.length > 0) {
						// 🔑 找到第一个可选的班期
						const firstSelectablePeriod = this.selectedDates.find(item => this.isPeriodSelectable(item))
						
						if (firstSelectablePeriod) {
							firstSelectablePeriod.isSelected = true
							selectedIds = [firstSelectablePeriod.periodId]
							this.hasPeriodSelected = true
							this.updateSelectedScheduleInfoByPeriod(firstSelectablePeriod)
							console.log('✅ 默认选中第一个可选班期（来自 getPeriods）:', firstSelectablePeriod.DateName, 'status:', firstSelectablePeriod.status)
						} else {
							console.log('⚠️ 没有可选的班期（来自 getPeriods），不默认选中')
							this.hasPeriodSelected = false
						}
					} else {
						this.hasPeriodSelected = selectedIds.length > 0
					}

					// 更新选中的班期ID列表
					this.selectedPeriodIds = selectedIds
				}

				// 不默认选中班期
				// if (this.schedules.length) {
				// 	this.selectedScheduleIndex = 0
				// 	this.selectSchedule(0)
				// }
				} else {
					uni.showToast({
						title: res?.message || '班期加载失败',
						icon: 'none'
					})
				}
			} catch (error) {
				console.error('加载班期数据失败:', error)
				uni.showToast({
					title: '加载失败',
					icon: 'none'
				})
			} finally {
				// 🔑 打印当前产品的 productType
				const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0
				const productTypeNum = Number(productType) || 0
				console.log('📋 当前产品的 productType:', productTypeNum, '(原始值:', productType, ')')
			}
		},

		// 🔑 获取自己产品班期的接口
		async getMyProductPeriods(productId) {
			try {
				const companyInfo = uni.getStorageSync('companyInfo') || {}
				const businessType = companyInfo.businessType || 1
				const res = await request({
					url: `/period-sku/getPeriodsFor?spuId=${productId}&merchantId=${companyInfo.id || ''}&merchantType=${businessType}`,
					method: 'GET'
				})
				
				console.log('📋 获取自己产品班期接口返回:', res, companyInfo)
				
				if (res && (res.code === 200 || res.code === 1)) {
					let periodData = null // B 状态的班期数据
					let aStateData = null // A 状态的班期数据（上一级）
					let periodSource = null // 当前使用的数据源
					
					// 按优先级选择数据源：p3s > p2s > p1s
					if (Array.isArray(res.data)) {
						// 如果返回的是数组，遍历每个元素按优先级查找数据源
						for (const group of res.data) {
							// 优先级：p3s > p2s > p1s
							if (Array.isArray(group.p3s) && group.p3s.length > 0) {
								periodData = group.p3s
								periodSource = 'p3s'
								// 🔑 p3s 的上一级是 p2s
								if (Array.isArray(group.p2s) && group.p2s.length > 0) {
									aStateData = group.p2s
									console.log('✅ 使用 p3s 数据源（B状态），p2s 作为 A 状态，B状态共', periodData.length, '个班期，A状态共', aStateData.length, '个班期')
								}
								break
							} else if (Array.isArray(group.p2s) && group.p2s.length > 0) {
								periodData = group.p2s
								periodSource = 'p2s'
								// 🔑 p2s 的上一级是 p1s
								if (Array.isArray(group.p1s) && group.p1s.length > 0) {
									aStateData = group.p1s
									console.log('✅ 使用 p2s 数据源（B状态），p1s 作为 A 状态，B状态共', periodData.length, '个班期，A状态共', aStateData.length, '个班期')
								}
								break
							} else if (Array.isArray(group.p1s) && group.p1s.length > 0) {
								periodData = group.p1s
								periodSource = 'p1s'
								// 🔑 p1s 没有上一级，A状态为空
								console.log('✅ 使用 p1s 数据源（B状态），没有上一级，A状态为空，B状态共', periodData.length, '个班期')
								break
							}
						}
					} else if (res.data) {
						// 如果返回的是单个对象，按优先级查找对应的数据源
						// 优先级：p3s > p2s > p1s
						if (Array.isArray(res.data.p3s) && res.data.p3s.length > 0) {
							periodData = res.data.p3s
							periodSource = 'p3s'
							// 🔑 p3s 的上一级是 p2s
							if (Array.isArray(res.data.p2s) && res.data.p2s.length > 0) {
								aStateData = res.data.p2s
								console.log('✅ 使用 p3s 数据源（B状态），p2s 作为 A 状态，B状态共', periodData.length, '个班期，A状态共', aStateData.length, '个班期')
							}
						} else if (Array.isArray(res.data.p2s) && res.data.p2s.length > 0) {
							periodData = res.data.p2s
							periodSource = 'p2s'
							// 🔑 p2s 的上一级是 p1s
							if (Array.isArray(res.data.p1s) && res.data.p1s.length > 0) {
								aStateData = res.data.p1s
								console.log('✅ 使用 p2s 数据源（B状态），p1s 作为 A 状态，B状态共', periodData.length, '个班期，A状态共', aStateData.length, '个班期')
							}
						} else if (Array.isArray(res.data.p1s) && res.data.p1s.length > 0) {
							periodData = res.data.p1s
							periodSource = 'p1s'
							// 🔑 p1s 没有上一级，A状态为空
							console.log('✅ 使用 p1s 数据源（B状态），没有上一级，A状态为空，B状态共', periodData.length, '个班期')
						}
					}
					
					if (periodData && Array.isArray(periodData) && periodData.length > 0) {
						// 🔑 返回对象，包含 B 状态数据、A 状态数据和数据源
						return {
							bStatePeriods: periodData, // B 状态的班期数据
							aStatePeriods: aStateData || [], // A 状态的班期数据（上一级）
							periodSource: periodSource // 当前使用的数据源
						}
					} else {
						console.warn('⚠️ 未找到班期数据（按优先级 p3s > p2s > p1s 查找）')
						return {
							bStatePeriods: [],
							aStatePeriods: [],
							periodSource: null
						}
					}
				} else {
					console.error('❌ 获取自己产品班期失败:', res?.message || '未知错误')
					uni.showToast({
						title: res?.message || '获取班期失败',
						icon: 'none'
					})
					return {
						bStatePeriods: [],
						aStatePeriods: [],
						periodSource: null
					}
				}
			} catch (error) {
				console.error('❌ 获取自己产品班期异常:', error)
				uni.showToast({
					title: '获取班期失败',
					icon: 'none'
				})
				return {
					bStatePeriods: [],
					aStatePeriods: [],
					periodSource: null
				}
			}
		},

		// 🔑 处理班期数据（将班期数据转换为页面需要的格式）
		processPeriodData(periodArray) {
			try {
				const schedules = []
				let saleArea = ''
				let saleMode = ''
				
				console.log('📋 处理班期数据，共', periodArray.length, '个班期')
				
				periodArray.forEach((it) => {
					// 提取 saleArea 和 saleMode 字段
					if (it.saleArea && !saleArea) {
						saleArea = it.saleArea
					}
					if (it.saleMode && !saleMode) {
						saleMode = it.saleMode
					}

					const ad = it.availableDate || {}
					const year = ad.yearDate ?? ad.year ?? ''
					const monthNum = ad.monthDate ?? ad.month ?? ''
					const dayNum = ad.dayDate ?? ad.day ?? ''
					const mm = monthNum !== '' ? String(monthNum).padStart(2, '0') : ''
					const dd = dayNum !== '' ? String(dayNum).padStart(2, '0') : ''
					const count = Number(it.fullNumberOfRegiment ?? it.groupCount ?? it.applyQuota ?? it.quota ?? 0)
					
					// 🔑 获取班期状态：0-申请中, 1-已同意, 2-已拒绝
					const status = it.status !== undefined ? Number(it.status) : null
					// status=1 可选，status=0 或 2 不可选
					const isSelectable = status === 1
					
					schedules.push({
						date: mm && dd ? `${mm}-${dd}` : '--',
						Datevalue1: mm && dd ? `${mm}-${dd}` : '--',
						WeekName: ad.weekDate || it.weekName || '—',
						year,
						month: mm,
						day: dd,
						dayLabel: ad.weekDate || it.weekName || '—',
						count,
						badgeType: count > 5 ? 'green' : 'red',
						selected: false,
						periodId: it.id || it.periodId || null,
						periodSource: 'getPeriodsFor',
						applicationDeadline: it.applicationDeadline || null,
						appendingGroups: it.appendingGroups || 0,
						repliedGroups: it.repliedGroups || 0,
						status: status, // 🔑 保存班期状态
						isSelectable: isSelectable // 🔑 保存是否可选
					})
				})

				// 更新 productInfo 中的 saleArea 和 saleMode
				if (saleArea || saleMode) {
					if (this.productInfo && this.productInfo.mainInfo) {
						if (!this.productInfo.mainInfo.productSku) {
							this.productInfo.mainInfo.productSku = {}
						}
						this.productInfo.mainInfo.productSku.saleArea = saleArea || '--'
						this.productInfo.mainInfo.productSku.saleMode = saleMode || '--'
					}
				}

				this.schedules = schedules
				console.log(`✅ 共加载 ${schedules.length} 个班期（来自 getMyProductPeriods）`)

				// 将班期数据转换为 selectedDates 格式（用于班期卡片显示）
				if (schedules.length > 0) {
					const selectedDatesFromSchedules = schedules.map((schedule, index) => {
						// 构建完整的日期字符串
						const dateStr = schedule.year && schedule.month && schedule.day ?
							`${schedule.year}-${schedule.month}-${schedule.day}` :
							(schedule.date ? `2024-${schedule.date}` : '')

						return {
							DateName: dateStr,
							WeekName: schedule.WeekName || schedule.dayLabel || '—',
							periodId: schedule.periodId || `period_${index}_${Date.now()}`,
							isSelected: false,
							originalIndex: index,
							appendingGroups: schedule.appendingGroups || 0,
							repliedGroups: schedule.repliedGroups || 0,
							status: schedule.status, // 🔑 保存班期状态
							isSelectable: schedule.isSelectable, // 🔑 保存是否可选
							periodData: {
								price: 0,
								leastNumberOfPeople: 20,
								fullNumberOfPeople: 30,
								inventory: schedule.count || 0,
								saleArea: saleArea || '--',
								applicationDeadline: schedule.applicationDeadline || this.applicationDeadline || 15
							}
						}
					})

					// 🔑 对班期列表按日期排序
					const sortedSelectedDatesFromSchedules = this.sortPeriodsByDate(selectedDatesFromSchedules)
					
					// 如果 selectedDates 为空或需要更新，则使用新的数据
					if (!this.selectedDates || this.selectedDates.length === 0) {
						this.selectedDates = sortedSelectedDatesFromSchedules
					} else {
						// 合并数据，保留已有的选中状态
						sortedSelectedDatesFromSchedules.forEach(newItem => {
							const existingItem = this.selectedDates.find(item =>
								item.periodId === newItem.periodId ||
								item.DateName === newItem.DateName
							)
							if (existingItem) {
								// 保留已有的选中状态
								newItem.isSelected = existingItem.isSelected
							}
						})
						this.selectedDates = sortedSelectedDatesFromSchedules
					}

					// 默认选中第一个班期（首次进入时）
					let selectedIds = this.selectedDates
						.filter(item => item.isSelected)
						.map(item => item.periodId)

					if (selectedIds.length === 0 && this.selectedDates.length > 0) {
						// 🔑 找到第一个可选的班期
						const firstSelectablePeriod = this.selectedDates.find(item => this.isPeriodSelectable(item))
						
						if (firstSelectablePeriod) {
							firstSelectablePeriod.isSelected = true
							selectedIds = [firstSelectablePeriod.periodId]
							this.hasPeriodSelected = true
							this.updateSelectedScheduleInfoByPeriod(firstSelectablePeriod)
							console.log('✅ 默认选中第一个可选班期（来自 getMyProductPeriods）:', firstSelectablePeriod.DateName, 'status:', firstSelectablePeriod.status)
						} else {
							console.log('⚠️ 没有可选的班期（来自 getMyProductPeriods），不默认选中')
							this.hasPeriodSelected = false
						}
					} else {
						this.hasPeriodSelected = selectedIds.length > 0
					}

					// 更新选中的班期ID列表
					this.selectedPeriodIds = selectedIds
				}
			} catch (error) {
				console.error('❌ 处理班期数据失败:', error)
			}
		},

		// 更新已选班期信息
		updateSelectedScheduleInfo(index) {
			const selectedSchedule = this.schedules[index]
			if (selectedSchedule) {
				// 构建完整的日期显示（優先使用後端年份）
				const fullDate = (selectedSchedule.year && selectedSchedule.month && selectedSchedule.day) ?
					`${selectedSchedule.year}年${selectedSchedule.month}月${selectedSchedule.day}日` :
					(selectedSchedule.date ? selectedSchedule.date.replace('-', '月') + '日' : '--')

				// 根据班期ID加载该班期的申请数据
				if (selectedSchedule.periodId) {
					this.loadPeriodApplications(selectedSchedule.periodId, fullDate)
				} else {
					// 如果没有班期ID，使用默认值
					this.loadScheduleDetailData(selectedSchedule.date, fullDate)
				}
			}
		},

		// 根据班期对象更新已选班期信息
		updateSelectedScheduleInfoByPeriod(periodItem) {
			if (!periodItem) return

			// 构建完整的日期显示
			const dateParts = periodItem.DateName ? periodItem.DateName.split('-') : []
			const fullDate = dateParts.length >= 3 ?
				`${dateParts[0]}年${dateParts[1]}月${dateParts[2]}日` :
				(periodItem.DateName || '--')

			// 根据班期ID加载该班期的申请数据
			if (periodItem.periodId) {
				this.loadPeriodApplications(periodItem.periodId, fullDate)
			} else {
				// 如果没有班期ID，使用默认值
				this.loadScheduleDetailData(periodItem.DateName, fullDate)
			}
		},

		// 根据班期ID加载申请数据
		async loadPeriodApplications(periodId, fullDate) {
			try {
				const companyInfo = uni.getStorageSync('companyInfo') || {}
				const merchantId = companyInfo.id || ''
				const businessType = companyInfo.businessType || 1
				const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0
				let isB1 = false

				// B3商家不展示合作申请管理
				if (businessType === 3) {
					console.log('B3商家不展示合作申请管理')
					return
				}

				// 根据产品类型选择合作申请接口
				const isProductTypeB1 = (productType == 1 || productType == 3)
				const isProductTypeB2 = (productType == 2 || productType == 4)
				let apiUrl = ''
				if (isProductTypeB1) {
					apiUrl = `/call-apply/list/cooperation/b1?periodId=${periodId}&merchantId=${merchantId}`
					isB1 = true
				} else if (isProductTypeB2) {
					apiUrl = `/call-apply/list/cooperation/b2?periodId=${periodId}&merchantId=${merchantId}`
					isB1 = false
				} else {
					apiUrl = businessType === 1
						? `/call-apply/list/cooperation/b1?periodId=${periodId}&merchantId=${merchantId}`
						: `/call-apply/list/cooperation/b2?periodId=${periodId}&merchantId=${merchantId}`
					isB1 = businessType === 1
				}

				const res = await request({
					url: apiUrl,
					method: 'GET'
				})

				console.log('班期申请接口返回:', res)

				if (res && (res.code === 200 || res.code === 1) && res.data) {
					const periodData = res.data
					const periodApplyList = periodData.periodApplyVOS || []

					// 判断使用团数还是小组数
					const unitText = isB1 ? '团' : '小组'
					console.log('periodApplyList',periodApplyList)
					// 过滤出待处理的申请（CallApply.status = WAIT_PROCESS）
					const pendingList = periodApplyList.filter(item => item.status === 0 || item.status === '待处理')
					this.pendingApplications = pendingList.map(item => {
						const count = isB1 ? (item.groups || 0) : (item.teams || 0)
						return {
							id: item.id,
							type: this.getBusinessTypeName(item.businessType),
							agencyName: item.merchantName || item.merchantDTO?.name || '未知机构',
							rating: '4.5',
							sourceCity: item.saleArea || item.periodSku?.saleArea || item.gatherArea,
							quota: `${item.campers || 0}人/${count}${unitText}`,
							relationId: item.id,
							applyReason: '',
							merchantInfo: item.merchantDTO,
							businessType: item.businessType,
							periodSku: item.periodSku
						}
					})

					// 过滤出已答复但未成团的申请（status = 1 表示已上架，< 3 表示未成团）
					const respondedList = periodApplyList.filter(item =>
						item.status != null && item.status >= 1 && item.status < 3
					)
					this.respondedApplications = respondedList.map(item => {
						const count = isB1 ? (item.groups || 0) : (item.teams || 0)
						return {
							id: item.id,
							type: this.getBusinessTypeName(item.businessType),
							agencyName: item.merchantName || item.merchantDTO?.name || '未知机构',
							rating: '4.5',
							sourceCity: item.saleArea || item.periodSku?.gatherArea || '未知地区',
							quota: `${item.campers || 0} / ${item.applicationQuota || 0}人 / ${count}${unitText}`,
							relationId: item.id,
							applyReason: '',
							reply: '',
							status: '已同意',
							merchantInfo: item.merchantDTO,
							businessType: item.businessType,
							periodSku: item.periodSku
						}
					})

					// 过滤出已确认成团的申请（status = 3 表示已成团）
					const confirmedList = periodApplyList.filter(item => item.status === 3)
					this.confirmedGroups = confirmedList.map(item => {
						const count = isB1 ? (item.groups || 0) : (item.teams || 0)
						return {
							id: item.id,
							type: this.getBusinessTypeName(item.businessType),
							agencyName: item.merchantName || item.merchantDTO?.name || '未知机构',
							rating: '4.5',
							sourceCity: item.saleArea || item.periodSku?.saleArea || '未知地区',
							quota: `${item.campers || 0} / ${item.applicationQuota || 0}人 / ${count}${unitText}`,
							relationId: item.id,
							merchantInfo: item.merchantDTO,
							businessType: item.businessType,
							periodSku: item.periodSku
						}
					})

					// 更新已选班期信息（使用实际列表的数量，与列表保持一致）
					// 计算待答复申请数量：累加列表中每个申请的 periodSku.fullNumberOfRegiment
					const pendingCount = this.pendingApplications.reduce((sum, item) => {
						const count = Number(item.periodSku?.fullNumberOfRegiment || 0)
						return sum + count
					}, 0)
					// 计算待答复申请名额：累加每个申请的 fullNumberOfPeople × fullNumberOfRegiment
					const pendingQuota = this.pendingApplications.reduce((sum, item) => {
						const people = Number(item.periodSku?.fullNumberOfPeople || 0)
						const regiment = Number(item.periodSku?.fullNumberOfRegiment || 0)
						return sum + (people * regiment)
					}, 0)
					// 计算已答复申请数量：累加列表中每个申请的 periodSku.fullNumberOfRegiment
					const repliedCount = this.respondedApplications.reduce((sum, item) => {
						const count = Number(item.periodSku?.fullNumberOfRegiment || 0)
						return sum + count
					}, 0)
					// 计算已答复申请名额：累加每个申请的 fullNumberOfPeople × fullNumberOfRegiment
					const repliedQuota = this.respondedApplications.reduce((sum, item) => {
						const people = Number(item.periodSku?.fullNumberOfPeople || 0)
						const regiment = Number(item.periodSku?.fullNumberOfRegiment || 0)
						return sum + (people * regiment)
					}, 0)

					const registeredGroupsValue = isB1
						? (periodData.registeredGroups || 0)
						: (periodData.registeredTeams || 0)
					this.selectedScheduleInfo = {
						date: fullDate,
						unitText: unitText, // 保存单位文本用于显示
						pendingApplications: {
							groupCount: pendingCount,
							quota: pendingQuota
						},
						respondedApplications: {
							groupCount: repliedCount,
							registered: periodData.registeredNumber || 0,
							registeredGroups: registeredGroupsValue,
							quota: repliedQuota
						}
					}
					console.log('看看班期加载的内容', this.selectedScheduleInfo)

				} else {
					console.error('加载班期申请失败:', res?.message)
				}
			} catch (error) {
				console.error('加载班期申请失败:', error)
			}
		},

		// 根据商家类型获取显示名称
		getBusinessTypeName(businessType) {
			const typeMap = {
				1: '一类商家',
				2: '组团',
				3: '旅行社'
			}
			return typeMap[businessType] || '未知'
		},

		// 根据商家类型获取报名详情按钮样式
		getRegistrationButtonStyle(businessType) {
			if (businessType === 2) {
				// businessType=2: 底#39B54A/10%透明 字#39B54A
				return {
					backgroundColor: 'rgba(57, 181, 74, 0.1)',
					color: '#39B54A',
					borderRadius: '5000rpx',
					// border: '1rpx solid #39B54A'
				}
			} else if (businessType === 3) {
				// businessType=3: 底#FBBD08 字#303030
				return {
					backgroundColor: '#FBBD08',
					color: '#303030',
					border: '1rpx solid #FBBD08'
				}
			}
			// 默认样式（businessType=2的样式）
			return {
				backgroundColor: 'rgba(57, 181, 74, 0.1)',
				color: '#39B54A',
				border: '1rpx solid #39B54A'
			}
		},

		// 获取名额标签（团数或小组数）
		getQuotaLabel() {
			const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0
			if (productType == 1 || productType == 3) {
				return '已报/申请/团数'
			}
			if (productType == 2 || productType == 4) {
				return '名额小组数'
			}
			return '名额'
		},

		// 加载特定班期的详细数据（兜底方法）
		async loadScheduleDetailData(scheduleDate, fullDate) {
			try {
				// TODO: 从API获取班期详细数据
				// 目前返回空数据，等待API接口实现
				const emptyData = {
					pendingApplications: {
						groupCount: 0,
						quota: 0
					},
					respondedApplications: {
						groupCount: 0,
						registered: 0,
						quota: 0
					}
				}

				// 存储到scheduleData中
				this.scheduleData[scheduleDate] = emptyData

				// 更新当前显示
				this.selectedScheduleInfo = {
					date: fullDate,
					...emptyData
				}
			} catch (error) {
				console.error('获取班期详细数据失败:', error)
			}
		},

		// 答复申请
		replyApplication(application) {
			console.log('答复申请', application)
			// 跳转到答复申请页面 传递所选日期,sourceCity城市，relationId,agencyName，type 
			const selectedDate = this.selectedScheduleInfo ? this.selectedScheduleInfo.date : '请选择班期'
			console.log('selectedDate', selectedDate)
			uni.navigateTo({
				url: `/public/cooperation/reply-application?date=${selectedDate}&sourceCity=${application.sourceCity}&relationId=${application.relationId}&agencyName=${application.agencyName}&type=${application.type}`
			})

		},

		// 查看报名详情
		viewRegistrationDetails(item) {
			console.log('查看报名详情', item)
			const selectedDate = this.selectedScheduleInfo ? this.selectedScheduleInfo.date : '请选择班期'
			// 获取选中的班期ID
			const selectedPeriod = this.selectedDates && this.selectedDates.find(p => p.isSelected)
			const periodId = selectedPeriod ? selectedPeriod.periodId : ''
			const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0
			uni.navigateTo({
				url: `/public/cooperation/registration-details?periodId=${periodId}&productType=${productType}&date=${encodeURIComponent(selectedDate)}`
			})
		},

		// 初始化选中的班期
		initSelectedSchedule() {
			// 🔑 优先从 selectedDates 中查找已选中的班期
			if (this.selectedDates && this.selectedDates.length > 0) {
				const selectedPeriod = this.selectedDates.find(item => item.isSelected)
				if (selectedPeriod) {
					// 🔑 检查选中的班期是否可选
					if (this.isPeriodSelectable(selectedPeriod)) {
						this.updateSelectedScheduleInfoByPeriod(selectedPeriod)
						console.log('✅ initSelectedSchedule: 使用已选中的可选班期:', selectedPeriod.DateName, 'status:', selectedPeriod.status)
					} else {
						console.log('⚠️ initSelectedSchedule: 已选中的班期不可选，清空选中状态')
						selectedPeriod.isSelected = false
						this.selectedScheduleInfo = null
						this.hasPeriodSelected = false
						this.selectedPeriodIds = []
					}
					return
				}
			}
			
			// 兜底：从 schedules 中查找选中的班期
			const selectedIndex = this.schedules.findIndex(schedule => schedule.selected)
			if (selectedIndex !== -1) {
				const selectedSchedule = this.schedules[selectedIndex]
				// 🔑 检查选中的班期是否可选（需要转换为 periodItem 格式）
				const periodItem = {
					DateName: selectedSchedule.year && selectedSchedule.month && selectedSchedule.day ?
						`${selectedSchedule.year}-${selectedSchedule.month}-${selectedSchedule.day}` :
						(selectedSchedule.date ? `2024-${selectedSchedule.date}` : ''),
					periodData: {
						applicationDeadline: selectedSchedule.applicationDeadline || this.applicationDeadline || 15
					},
					status: selectedSchedule.status
				}
				
				if (this.isPeriodSelectable(periodItem)) {
					this.updateSelectedScheduleInfo(selectedIndex)
					console.log('✅ initSelectedSchedule: 使用 schedules 中选中的可选班期')
				} else {
					console.log('⚠️ initSelectedSchedule: schedules 中选中的班期不可选，清空选中状态')
					this.selectedScheduleInfo = null
				}
			} else {
				// 如果没有选中的班期，显示默认状态
				this.selectedScheduleInfo = null
			}
		},

		// 查看上架详情
		viewShelfDetails() {
			uni.navigateTo({
				url: `/public/cooperation/shelf-details?productId=${this.productId}`
			})
		},

		// 查看申请记录
		viewApplicationRecord() {
			if (!this.productId) {
				uni.showToast({
					title: '产品ID不存在',
					icon: 'none'
				})
				return
			}
			uni.navigateTo({
				url: `/public/cooperation/application-record?productId=${this.productId}`
			})
		},
		// 🔑 更新 productType 1 或 3 的班期（调用 updatePeriodOdd 接口）
		async updatePeriodOddForProductType1Or3(selectedDates) {
			try {
				if (!this.productId) {
					console.error('[合作申请管理] 产品ID不存在，无法更新班期')
					return
				}
				
				// 将班期数据转换为接口需要的格式
				const periodDates = selectedDates.map(period => {
					// 优先从 availableDate 获取
					if (period.availableDate) {
						const { yearDate, monthDate, dayDate, weekDate } = period.availableDate
						return {
							yearDate: String(yearDate || ''),
							monthDate: String(monthDate || '').padStart(2, '0'),
							dayDate: String(dayDate || '').padStart(2, '0'),
							weekDate: weekDate || this.getWeekDateFromDateName(period.DateName)
						}
					}
					
					// 如果没有 availableDate，从 DateName 解析
					if (period.DateName) {
						const dateParts = period.DateName.split('-')
						if (dateParts.length >= 3) {
							const year = dateParts[0]
							const month = String(dateParts[1]).padStart(2, '0')
							const day = String(dateParts[2]).padStart(2, '0')
							return {
								yearDate: year,
								monthDate: month,
								dayDate: day,
								weekDate: period.WeekName || this.getWeekDateFromDateName(period.DateName)
							}
						}
					}
					
					return null
				}).filter(item => item !== null) // 过滤掉无效的数据
				
				if (periodDates.length === 0) {
					console.warn('[合作申请管理] 没有有效的班期数据，跳过更新')
					return
				}
				
				console.log('[合作申请管理] 准备调用 updatePeriodOdd 接口，产品ID:', this.productId)
				console.log('[合作申请管理] 班期数据（数组）:', periodDates)
				console.log('[合作申请管理] 班期数据（JSON格式）:', JSON.stringify(periodDates, null, 2))
				
				const res = await request({
					url: `/call-apply/updatePeriodOdd?spuId=${this.productId}`,
					method: 'PUT',
					data: periodDates
				})
				
				if (res && (res.code === 200 || res.code === 1)) {
					console.log('[合作申请管理] ✅ updatePeriodOdd 接口调用成功:', res)
					uni.showToast({
						title: '班期更新成功',
						icon: 'success'
					})
				} else {
					console.error('[合作申请管理] ❌ updatePeriodOdd 接口调用失败:', res)
					uni.showToast({
						title: res?.message || '班期更新失败',
						icon: 'none'
					})
				}
			} catch (error) {
				console.error('[合作申请管理] updatePeriodOdd 接口调用异常:', error)
				uni.showToast({
					title: '班期更新失败',
					icon: 'none'
				})
			}
		},
		
		// 从 DateName 获取星期（辅助方法）
		getWeekDateFromDateName(dateName) {
			if (!dateName) return ''
			try {
				const date = new Date(dateName)
				const weekDays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
				return weekDays[date.getDay()] || ''
			} catch (e) {
				return ''
			}
		},
		
		// 🔑 对班期列表按日期排序（升序）
		sortPeriodsByDate(periods) {
			if (!periods || !Array.isArray(periods) || periods.length === 0) {
				return periods
			}
			
			return [...periods].sort((a, b) => {
				// 获取日期字符串进行比较
				const dateA = a.DateName || ''
				const dateB = b.DateName || ''
				
				// 如果日期字符串格式为 YYYY-MM-DD，可以直接比较
				if (dateA && dateB) {
					return dateA.localeCompare(dateB)
				}
				
				// 如果没有 DateName，尝试从 availableDate 获取
				if (a.availableDate && b.availableDate) {
					const dateStrA = `${a.availableDate.yearDate || ''}-${String(a.availableDate.monthDate || '').padStart(2, '0')}-${String(a.availableDate.dayDate || '').padStart(2, '0')}`
					const dateStrB = `${b.availableDate.yearDate || ''}-${String(b.availableDate.monthDate || '').padStart(2, '0')}-${String(b.availableDate.dayDate || '').padStart(2, '0')}`
					return dateStrA.localeCompare(dateStrB)
				}
				
				return 0
			})
		},
		
		// 🔑 将班期数据转换为日期对象数组格式（用于 updatePeriodEven 接口）
		convertPeriodsToDateList(periods) {
			if (!periods || !Array.isArray(periods)) {
				return []
			}
			
			return periods.map(period => {
				// 优先从 availableDate 获取
				if (period.availableDate) {
					const { yearDate, monthDate, dayDate, weekDate } = period.availableDate
					return {
						yearDate: String(yearDate || ''),
						monthDate: String(monthDate || '').padStart(2, '0'),
						dayDate: String(dayDate || '').padStart(2, '0'),
						weekDate: weekDate || this.getWeekDateFromDateName(period.DateName)
					}
				}
				
				// 如果没有 availableDate，从 DateName 解析
				if (period.DateName) {
					const dateParts = period.DateName.split('-')
					if (dateParts.length >= 3) {
						const year = dateParts[0]
						const month = String(dateParts[1]).padStart(2, '0')
						const day = String(dateParts[2]).padStart(2, '0')
						return {
							yearDate: year,
							monthDate: month,
							dayDate: day,
							weekDate: period.WeekName || this.getWeekDateFromDateName(period.DateName)
						}
					}
				}
				
				return null
			}).filter(item => item !== null) // 过滤掉无效的数据
		},
		
		// 🔑 更新 productType 2 或 4 的班期（调用 updatePeriodEven 接口）
		async updatePeriodEvenForProductType2Or4(updateSelectedDates, previousSelectedDates) {
			try {
				if (!this.productId) {
					console.error('[合作申请管理] 产品ID不存在，无法更新班期')
					return
				}
				
				// 准备三个日期列表
				// 1. parentAvailableDateList: 父类班期日期集合（A状态的班期）- 从 getPeriodsFor 返回的上级数据获取
				// 直接使用 this.aStatePeriods（getPeriodsFor 接口返回的 A 状态数据，即上级数据）
				const parentAvailableDateList = this.convertPeriodsToDateList(this.aStatePeriods || [])
				console.log('[合作申请管理] 从 getPeriodsFor 返回的 A 状态数据（上级）获取 parentAvailableDateList:', parentAvailableDateList)
				
				// 2. callAvailableDateList: 已调用班期日期集合（之前的选中班期）
				const callAvailableDateList = this.convertPeriodsToDateList(previousSelectedDates || [])
				
				// 3. updateAvailableDateList: 更新选中状态后的班期日期集合（当前返回的选中班期）
				const updateAvailableDateList = this.convertPeriodsToDateList(updateSelectedDates)
				
				const requestData = {
					parentAvailableDateList: parentAvailableDateList,
					callAvailableDateList: callAvailableDateList,
					updateAvailableDateList: updateAvailableDateList
				}
				
				console.log('[合作申请管理] 准备调用 updatePeriodEven 接口，产品ID:', this.productId)
				console.log('[合作申请管理] 请求数据（对象）:', requestData)
				console.log('[合作申请管理] 请求数据（JSON格式）:', JSON.stringify(requestData, null, 2))
				console.log('requestData',requestData)
				// return ; 
				const res = await request({
					url: `/call-apply/updatePeriodEven?spuId=${this.productId}`,
					method: 'PUT',
					data: requestData
				})
				
				if (res && (res.code === 200 || res.code === 1)) {
					console.log('[合作申请管理] ✅ updatePeriodEven 接口调用成功:', res)
					uni.showToast({
						title: '班期更新成功',
						icon: 'success'
					})
				} else {
					console.error('[合作申请管理] ❌ updatePeriodEven 接口调用失败:', res)
					uni.showToast({
						title: res?.message || '班期更新失败',
						icon: 'none'
					})
				}
			} catch (error) {
				console.error('[合作申请管理] updatePeriodEven 接口调用异常:', error)
				uni.showToast({
					title: '班期更新失败',
					icon: 'none'
				})
			}
		},
		
		// 🔑 处理新选中的班期，准备申请数据并调用 apply-batch 接口
		async handleNewSelectedPeriods(newSelectedPeriods) {
			try {
				console.log('[合作申请管理] 开始处理新选中的班期，数量:', newSelectedPeriods.length)
				
				// 准备申请数据数组
				const applyForms = newSelectedPeriods.map(period => {
					const applyData = this.prepareApplyData(period)
					// 🔑 准备 periodSku 数据并合并到 applyData
					const periodSku = this.preparePeriodSku(period)
					if (periodSku) {
						applyData.periodSku = periodSku
					}
					return applyData
				})
				
				console.log('[合作申请管理] 准备的申请数据（包含 periodSku）:', applyForms)
				
				// 调用批量申请接口
				if (applyForms.length > 1) {
					await this.applyPeriodBatch(applyForms)
				} else if (applyForms.length === 1) {
					await this.applyPeriod(applyForms[0])
				}
				
				uni.showToast({
					title: `已提交${applyForms.length}个班期申请`,
					icon: 'success',
					duration: 2000
				})
				
				// 刷新班期数据
				if (this.productId) {
					await this.loadScheduleData(this.productId)
				}
			} catch (error) {
				console.error('[合作申请管理] 处理新选中班期失败:', error)
				uni.showToast({
					title: error.message || '提交申请失败',
					icon: 'none',
					duration: 2000
				})
			}
		},
		
		// 🔑 准备 periodSku 数据（参照 periodCreate.vue 的 preparePeriodData）
		preparePeriodSku(selectedPeriod) {
			try {
				const companyInfo = uni.getStorageSync('companyInfo') || {}
				const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0
				const businessType = companyInfo.businessType || 1
				
				console.log('[合作申请管理] 准备 periodSku 数据:', {
					productId: this.productId,
					periodId: selectedPeriod.periodId,
					productType: productType,
					businessType: businessType
				})
				
				// 1. 处理 availableDate（确保格式正确：dayDate 和 monthDate 为两位数字字符串，weekDate 包含"周"字）
				let availableDate = null
				
				// 如果 selectedPeriod.availableDate 存在，使用它但需要格式化
				if (selectedPeriod.availableDate) {
					const ad = selectedPeriod.availableDate
					availableDate = {
						yearDate: String(ad.yearDate || ad.year || ''),
						monthDate: String(ad.monthDate || ad.month || '').padStart(2, '0'), // 补齐前导零，确保两位数字
						dayDate: String(ad.dayDate || ad.day || '').padStart(2, '0'), // 补齐前导零，确保两位数字
						weekDate: String(ad.weekDate || ad.week || selectedPeriod.WeekName || '') // 保留"周"字
					}
				} else if (selectedPeriod.DateName) {
					// 从 DateName 转换（格式：YYYY-MM-DD）
					const dateParts = selectedPeriod.DateName.split('-')
					if (dateParts.length >= 3) {
						const year = dateParts[0]
						const month = String(dateParts[1]).padStart(2, '0') // 补齐前导零
						const day = String(dateParts[2]).padStart(2, '0') // 补齐前导零
						const weekName = selectedPeriod.WeekName || ''
						
						availableDate = {
							yearDate: String(year),
							monthDate: month,
							dayDate: day,
							weekDate: weekName // 保留原始格式（包含"周"字）
						}
					}
				}
				
				if (!availableDate || !availableDate.yearDate || !availableDate.monthDate || !availableDate.dayDate) {
					console.warn('[合作申请管理] ⚠️ 无法获取 availableDate，跳过 periodSku 准备', availableDate)
					return null
				}
				
				console.log('[合作申请管理] ✅ availableDate 格式化完成:', availableDate)
				
				// 2. 从 aStatePeriods 中查找匹配的班期（用于获取上游数据）
				let sourcePeriod = null
				if (this.aStatePeriods && this.aStatePeriods.length > 0) {
					// 优先通过 periodId 匹配
					sourcePeriod = this.aStatePeriods.find(p => 
						p.id === selectedPeriod.periodId || 
						p.periodId === selectedPeriod.periodId
					)
					// 如果没有匹配，使用第一个作为参考
					if (!sourcePeriod) {
						sourcePeriod = this.aStatePeriods[0]
					}
				}
				
				// 3. 🔑 获取联系人数据（优先级最高的，即当前用户自己的联系人）
				let contact = []
				const contactArray = selectedPeriod.contact || []
				
				if (contactArray && contactArray.length > 0) {
					// 如果 contact 是单个对象，转换为数组
					const contacts = Array.isArray(contactArray) ? contactArray : [contactArray]
					
					// 获取优先级最高的联系人（当前用户自己的联系人）
					let highestPriorityContact = null
					const currentMerchantId = companyInfo.id
					
					// 方式1：通过 merchantId 匹配（推荐）
					highestPriorityContact = contacts.find(c => 
						c.merchantId === currentMerchantId
					)
					
					// 方式2：如果没有 merchantId 字段，通过 priority 排序
					if (!highestPriorityContact) {
						const sortedContacts = contacts.sort((a, b) => {
							const priorityA = a.priority || 0
							const priorityB = b.priority || 0
							return priorityB - priorityA // 降序
						})
						highestPriorityContact = sortedContacts[0]
					}
					
					// 方式3：如果还没有，使用第一个
					if (!highestPriorityContact && contacts.length > 0) {
						highestPriorityContact = contacts[0]
					}
					
					// 格式化联系人数据
					if (highestPriorityContact) {
						contact = [{
							category: highestPriorityContact.category || '报名联系人',
							name: highestPriorityContact.name || '',
							phone: highestPriorityContact.phone || highestPriorityContact.phoneNumber || '',
							productType: highestPriorityContact.productType !== undefined && highestPriorityContact.productType !== null
								? Number(highestPriorityContact.productType)
								: Number(productType) || undefined
						}]
						console.log('[合作申请管理] ✅ 获取到优先级最高的联系人:', contact)
					} else {
						console.warn('[合作申请管理] ⚠️ 未找到联系人数据')
					}
				} else {
					console.warn('[合作申请管理] ⚠️ selectedPeriod.contact 为空或不存在')
				}
				
				// 4. 获取其他字段（从 sourcePeriod 或 selectedPeriod 中获取）
				const applicationDeadline = parseInt(
					selectedPeriod.applicationDeadline || 
					sourcePeriod?.applicationDeadline || 
					this.applicationDeadline || 
					10
				)
				
				const confirmationTime = parseInt(
					sourcePeriod?.confirmationTime || 
					selectedPeriod.confirmationTime || 
					0
				)
				
				const fullNumberOfPeople = parseInt(
					sourcePeriod?.fullNumberOfPeople || 
					selectedPeriod.fullNumberOfPeople || 
					this.maxPeople || 
					30
				)
				
				const leastNumberOfPeople = parseInt(
					sourcePeriod?.leastNumberOfPeople || 
					selectedPeriod.leastNumberOfPeople || 
					12
				)
				
				const fullNumberOfRegiment = parseInt(
					sourcePeriod?.fullNumberOfRegiment || 
					selectedPeriod.fullNumberOfRegiment || 
					0
				)
				
				const saleArea = selectedPeriod.saleArea || 
					this.productInfo?.mainInfo?.productSku?.saleArea || 
					''
				
				const saleMode = this.productInfo?.mainInfo?.productSku?.saleMode || 
					'API渠道协作'
				
				const gatherArea = sourcePeriod?.gatherArea || 
					selectedPeriod.gatherArea || 
					''
				
				const rate = parseFloat(
					this.productInfo?.mainInfo?.productSku?.rate
				) || 0.06
				
				// 5. 根据业务类型获取价格字段
				let priceFields = {}
				if (businessType === 2 && (productType === 4 || productType === '4')) {
					// 二类商家申请调用（组团业务）
					priceFields = {
						secondServicePrice: parseFloat(
							selectedPeriod.secondServicePrice || 
							sourcePeriod?.secondServicePrice || 
							0
						),
						secondAddedServicePrice: parseFloat(
							selectedPeriod.secondAddedServicePrice || 
							sourcePeriod?.secondAddedServicePrice || 
							0
						),
						secondEstimatedPrice: parseFloat(
							selectedPeriod.secondEstimatedPrice || 
							sourcePeriod?.secondEstimatedPrice || 
							0
						),
						secondTotalPrice: parseFloat(
							selectedPeriod.secondTotalPrice || 
							sourcePeriod?.secondTotalPrice || 
							0
						)
					}
				} else if (businessType === 3 && (productType === 5 || productType === '5')) {
					// 三类商家申请调用（研学活动）
					priceFields = {
						thirdServicePrice: parseFloat(
							selectedPeriod.thirdServicePrice || 
							sourcePeriod?.thirdServicePrice || 
							0
						),
						thirdAddedServicePrice: parseFloat(
							selectedPeriod.thirdAddedServicePrice || 
							sourcePeriod?.thirdAddedServicePrice || 
							0
						),
						thirdEstimatedPrice: parseFloat(
							selectedPeriod.thirdEstimatedPrice || 
							sourcePeriod?.thirdEstimatedPrice || 
							0
						),
						totalPrice: parseFloat(
							selectedPeriod.totalPrice || 
							sourcePeriod?.totalPrice || 
							0
						)
					}
				}
				
				// 6. 组装 periodSku 对象
				const periodSku = {
					spuId: Number(this.productId),
					merchantId: Number(companyInfo.id),
					availableDate: availableDate,
					applicationDeadline: applicationDeadline,
					confirmationTime: confirmationTime,
					fullNumberOfPeople: fullNumberOfPeople,
					leastNumberOfPeople: leastNumberOfPeople,
					fullNumberOfRegiment: fullNumberOfRegiment,
					contact: contact,
					status: 0, // 申请中
					inventory: fullNumberOfPeople,
					saleArea: saleArea,
					saleMode: saleMode,
					gatherArea: gatherArea,
					rate: rate,
					// 小组设置（如果有）
					...(sourcePeriod?.groupMaxPeople ? { groupMaxPeople: parseInt(sourcePeriod.groupMaxPeople) } : {}),
					...(sourcePeriod?.groupMinPeople ? { groupMinPeople: parseInt(sourcePeriod.groupMinPeople) } : {}),
					// 价格字段
					...priceFields
				}
				
				// 三类商家申请调用时，设置 teamMembers（如果需要）
				if (businessType === 3 && sourcePeriod?.teamMembers && Array.isArray(sourcePeriod.teamMembers) && sourcePeriod.teamMembers.length > 0) {
					periodSku.teamMembers = sourcePeriod.teamMembers
				}
				
				console.log('[合作申请管理] ✅ periodSku 数据准备完成:', periodSku)
				return periodSku
			} catch (error) {
				console.error('[合作申请管理] ❌ 准备 periodSku 数据失败:', error)
				return null
			}
		},
		
		// 🔑 准备申请数据（参照 periodCreate.vue 的 prepareApplyData）
		prepareApplyData(selectedPeriod) {
			const companyInfo = uni.getStorageSync('companyInfo') || {}
			const productType = this.productInfo?.productType || this.productInfo?.mainInfo?.productSpu?.productType || 0
			
			console.log('[合作申请管理] 准备申请数据:', {
				productId: this.productId,
				periodId: selectedPeriod.periodId,
				productType: productType
			})
			
			// 获取源商家ID（从 aStatePeriods 中获取，或从 period 中获取）
			let sourceMerchantId = null
			let sourceMerchantType = null
			
			if (this.aStatePeriods && this.aStatePeriods.length > 0) {
				const firstAPeriod = this.aStatePeriods[0]
				sourceMerchantId = firstAPeriod.merchantId
				// 根据 periodSource 推断源商家类型
				if (this.periodSource === 'p3s') {
					sourceMerchantType = 2 // p3s 来自二类商家
				} else if (this.periodSource === 'p2s') {
					sourceMerchantType = 1 // p2s 来自一类商家
				} else if (this.periodSource === 'p1s') {
					sourceMerchantType = 1 // p1s 来自一类商家
				}
			}
			
			// 如果从 period 中获取不到，尝试从 selectedPeriod 中获取
			if (!sourceMerchantId && selectedPeriod.merchantId) {
				sourceMerchantId = selectedPeriod.merchantId
			}
			
			// 从产品信息中获取SKU ID
			const sourceSkuId = this.productInfo?.mainInfo?.productSku?.id
			
			const applyData = {
				spuId: Number(this.productId), // 源SPU ID
				skuId: sourceSkuId ? Number(sourceSkuId) : undefined, // 源SKU ID
				periodId: selectedPeriod.periodId ? Number(selectedPeriod.periodId) : undefined, // 源班期ID
				sourceMerchantId: sourceMerchantId ? Number(sourceMerchantId) : undefined, // 源商家ID
				sourceMerchantType: sourceMerchantType || 1, // 源商家类型（默认一类商家）
				targetMerchantId: Number(companyInfo.id), // 目标商家ID（当前商家）
				targetMerchantType: Number(companyInfo.businessType), // 目标商家类型
				isAllowRecursive: 0, // 不允许递归调用
				applyReason: '申请合作',
				salePrice: String(selectedPeriod.price || selectedPeriod.periodData?.price || 0), // 销售价格
				saleArea: selectedPeriod.saleArea || this.productInfo?.mainInfo?.productSku?.saleArea || '', // 销售区域
				status: 0, // 申请中
				sourceProductType: Number(productType)
			}
			
			console.log('[合作申请管理] 申请数据准备完成:', applyData)
			return applyData
		},
		
		// 🔑 申请班期（单个）
		async applyPeriod(applyData) {
			try {
				console.log('[合作申请管理] 调用申请接口，参数:', applyData)
				const res = await request({
					url: '/call-apply/apply',
					method: 'POST',
					data: applyData,
					loading: true
				})
				
				console.log('[合作申请管理] 申请接口返回:', res)
				if (res.code === 200) {
					return res.data
				} else {
					throw new Error(res.message || res.msg || '申请提交失败')
				}
			} catch (error) {
				console.error('[合作申请管理] 申请提交失败:', error)
				throw error
			}
		},
		
		// 🔑 批量申请班期（参照 periodCreate.vue 的 applyPeriodBatch）
		async applyPeriodBatch(applyForms) {
			try {
				console.log('[合作申请管理] 调用批量申请接口，参数:', applyForms)
				const res = await request({
					url: '/call-apply/apply-batch',
					method: 'POST',
					data: applyForms,
					loading: true
				})
				console.log('[合作申请管理] 批量申请接口返回:', res)
				if (res.code === 200) {
					return res.data
				} else {
					throw new Error(res.message || res.msg || '批量申请提交失败')
				}
			} catch (error) {
				console.error('[合作申请管理] 批量申请提交失败:', error)
				throw error
			}
		},
		
		// 加载申请数据
		async loadApplicationData() {
			try {
				// 只调用一次接口获取所有申请数据
				await this.loadAllApplications()
				// 加载已确认成团数据
				await this.loadConfirmedGroups()
			} catch (error) {
				console.error('加载申请数据失败:', error)
			}
		},

		// 加载所有申请数据（只调用一次接口）
		async loadAllApplications() {
			try {
				if (!this.productId) {
					console.error('加载申请数据失败: 缺少产品ID')
					uni.showToast({
						title: '缺少产品ID',
						icon: 'none'
					})
					return
				}
				const companyInfo = uni.getStorageSync('companyInfo') || {}
				const merchantId = companyInfo.id || ''
				// 调用申请列表接口
				const res = await request({
					url: `/call-apply/list/spu?spuId=${this.productId}&merchantId=${merchantId}`,
					method: 'GET'
				})

				console.log('接口返回的完整响应:', res)

				if (res.code === 200) {
					console.log('接口返回的原始数据:', res.data)

					// 过滤出待处理的申请
					const pendingList = res.data.filter(item => item.status === 0)
					console.log('待处理申请列表:', pendingList)

					this.pendingApplications = pendingList.map(item => ({
						id: item.id,
						type: '组团',
						agencyName: item.merchantDTO?.name || '未知机构',
						rating: '4.5', // 默认评分，实际应该从接口获取
						sourceCity: item.merchantDTO?.address || '未知城市',
						quota: `${item.applyQuota || 0}人/${item.groupCount || 0}团`,
						relationId: item.relationId,
						applyReason: item.applyReason || '无',
						merchantInfo: item.merchantDTO,
						businessType: item.merchantDTO?.businessType || 2 // 添加 businessType
					}))
					console.log('处理后的待答复申请:', this.pendingApplications)

					// 过滤出已答复的申请（同意或拒绝）
					const respondedList = res.data.filter(item =>
						item.status === '同意' || item.status === '拒绝' || item.status === '已同意' || item
							.status === '已拒绝'
					)
					console.log('已答复申请列表:', respondedList)

					this.respondedApplications = respondedList.map(item => ({
						id: item.id,
						type: '组团',
						agencyName: item.merchantDTO?.name || '未知机构',
						rating: '4.5', // 默认评分，实际应该从接口获取
						sourceCity: item.merchantDTO?.address || '未知城市',
						quota: `${item.applyQuota || 0}人/${item.groupCount || 0}团`,
						relationId: item.relationId,
						applyReason: item.applyReason || '无',
						reply: item.reply || '无',
						status: item.status,
						merchantInfo: item.merchantDTO,
						businessType: item.merchantDTO?.businessType || 2 // 添加 businessType
					}))
					console.log('处理后的已答复申请:', this.respondedApplications)
				} else {
					console.error('加载申请数据失败:', res.message)
					uni.showToast({
						title: res.message || '加载失败',
						icon: 'none'
					})
				}
			} catch (error) {
				console.error('加载申请数据失败:', error)
				uni.showToast({
					title: '加载失败',
					icon: 'none'
				})
			}
		},

		// 加载已确认成团
		async loadConfirmedGroups() {
			try {
				// 暂时使用初始数据，接口准备好后替换
			} catch (error) {
				console.error('加载已确认成团失败:', error)
			}
		},

	}
}
</script>

<style lang="scss" scoped>
// 全局变量定义
$primary-color: #3FBDA3; // 主题绿，贴近设计稿
$secondary-color: #82A0F7;
$danger-color: #FF3B30;
$warning-color: #FC642F;
$success-color: #4CAF50;
$gray-color: #8E8E93;
$light-gray: #F1F1F1;
$border-color: #EEEEEE;
$text-primary: #333333;
$text-secondary: #999999;
$text-light: #FFFFFF;
$radius-base: 12rpx;
$radius-large: 20rpx;
$shadow-sm: 0 2rpx 10rpx rgba(0, 0, 0, 0.08);
$shadow-md: 0rpx -4rpx 14rpx 0rpx rgba(241, 241, 241, 0.5);
$transition-base: all 0.3s ease;

.cooperation-container {
	// height: 100vh;
	// background-color: $light-gray;
	position: relative;
}

// 加载状态
.loading-container {
	position: fixed;
	top: 0;
	left: 0;
	right: 0;
	bottom: 0;
	background-color: rgba(255, 255, 255, 0.9);
	display: flex;
	flex-direction: column;
	justify-content: center;
	align-items: center;
	z-index: 1000;

	.loading-text {
		margin-top: 20rpx;
		font-size: 28rpx;
		color: $text-secondary;
	}
}

// 主要内容区域
.main-content {
	// padding-top: 20rpx;
	padding-bottom: 180rpx;
	// padding-left: 20rpx;
	// padding-right: 20rpx;
	// min-height: calc(100vh - 200rpx);
	// z-index: 2;
}

/* 顶部背景 */
.page-top-bg {
	position: fixed;
	top: 0;
	left: 0;
	width: 750rpx;
	height: 280rpx;
	background: #0081ff;
	box-shadow: 0rpx 4rpx 24rpx 0rpx rgba(216, 216, 216, 0.72);
	backdrop-filter: blur(0px);
	pointer-events: none; // 不拦截点击
}

/* 内容区域 */
.content-area {
	background: #eeeeee;
}

/* 顶部导航栏 */
.top-nav {
	background-color: #007aff;
	color: white;
	padding: 20rpx;
	display: flex;
	align-items: center;
	justify-content: space-between;
	min-height: 88rpx;
	box-sizing: border-box;
}

.nav-left {
	display: flex;
	align-items: center;
}

.back-icon {
	font-size: 32rpx;
	margin-right: 8rpx;
}

.back-text {
	font-size: 28rpx;
}

.nav-center {
	display: flex;
	flex-direction: column;
	align-items: center;
	justify-content: center;
	flex: 1;
}

.nav-subtitle {
	font-size: 20rpx;
	margin-bottom: 4rpx;
	color: white;
}

.nav-title {
	font-size: 32rpx;
	font-weight: 600;
	color: white;
}

.nav-right-placeholder {
	width: 120rpx;
}

.nav-icons {
	display: flex;
	gap: 12rpx;
}

.icon {
	font-size: 24rpx;
}

.main-top-period {
	margin: 20rpx;
	padding: 28rpx 20rpx 12rpx 20rpx;
	background: #FFFFFF;
	border-radius: 20rpx;
}

// 产品信息卡片包装器
.product-card-wrapper {
	padding: 5rpx;
}

// 通用区块样式
.section {
	// background-color: $text-light;
	// border-radius: $radius-large;
	// margin-bottom: 20rpx;
	// overflow: hidden;
	// border: 1rpx solid #f1f1f1;
	// box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.03);
	// transition: $transition-base;
	background: #ffffff;
	margin: 24rpx;
	border-radius: 20rpx;

	&-header {
		display: flex;
		// justify-content: space-between;
		align-items: center;
		padding: 28rpx;
		// border-bottom: 1rpx solid #f5f5f5;

		&__left {
			display: flex;
			align-items: center;
		}

		&__icon {
			width: 30rpx;
			height: 30rpx;
			margin-right: 20rpx;
			font-size: 28rpx;
			color: #787878;
			display: flex;
			align-items: center;
			justify-content: center;
			background: #f2f2f2;
		}

		&__title {
			font-size: 28rpx;
			font-weight: 600;
			color: $text-primary;
		}

		&__add-btn {
			padding: 8rpx 20rpx;
			background: rgba(255, 255, 255, 0.1);
			border-radius: 8rpx;
			color: #FC642F;
			font-size: 24rpx;
			border: 1rpx solid #FC642F;

			&:active {
				transform: scale(0.95);
				background-color: rgba($primary-color, 0.15);
			}
		}

		&__buttons {
			display: flex;
			gap: 15rpx;
		}

		&__btn {
			border: none;
			border-radius: 38rpx;
			padding: 0 20rpx;
			height: 70rpx;
			line-height: 70rpx;
			font-size: 26rpx;
			display: inline-flex;
			align-items: center;
			justify-content: center;
			border: 1rpx solid rgba($primary-color, 0.35);
			color: $primary-color;
			background-color: rgba($primary-color, 0.06);
			box-shadow: 0 2rpx 8rpx rgba($primary-color, 0.15);
			transition: $transition-base;

			&:active {
				transform: scale(0.95);
				background-color: rgba($primary-color, 0.15);
			}
		}
	}

	&-description {
		font-size: 24rpx;
		color: $text-secondary;
		padding: 0rpx 30rpx 20rpx;
		line-height: 1.5;
	}
}

/* 更多按钮 */
.more-btn {
	display: flex;
	align-items: center;
	padding: 8rpx 16rpx;
	background: rgba(255, 103, 0, 0.1);
	border-radius: 20rpx;
	cursor: pointer;
}

.more-text {
	font-size: 24rpx;
	color: #ff6700;
	margin-right: 6rpx;
}

// 班期卡片容器
.period-cards-container {
	padding: 20rpx 30rpx 20rpx 0rpx;
	display: flex;
	flex-wrap: nowrap; // 默认单行
	gap: 15rpx;
	overflow-x: auto;
	-webkit-overflow-scrolling: touch;
	white-space: nowrap;
	scrollbar-width: none;

	&::-webkit-scrollbar {
		display: none;
		height: 0;
		width: 0;
	}

	&.expanded {
		flex-wrap: wrap; // 展开后多行显示
		overflow-x: visible;
		white-space: normal;
	}
}

// 班期卡片样式
.period-card {
	position: relative;
	flex: 0 0 104rpx; // 固定卡片宽度
	width: 104rpx;
	min-width: 104rpx;
	background-color: #f8f8f8;
	border: 1rpx solid #f8f8f8;
	border-radius: 8rpx;
	// padding: 16rpx 6rpx;
	transition: all 0.3s ease;
	box-shadow: 0 1rpx 4rpx rgba(0, 0, 0, 0.05);
	display: flex;
	flex-direction: column;
	align-items: center;
	justify-content: center;
	height: 120rpx;
	min-height: 120rpx;

	&:active {
		transform: scale(0.95);
	}

	&.selected {
		border-color: #FF6B35 !important;
		background-color: #f8f8f8 !important;
		color: #FF6B35 !important;
		box-shadow: 0 4rpx 12rpx rgba(255, 107, 53, 0.2) !important;
		transform: scale(1.02);

		.period-card__month-day {
			color: #FF6B35 !important;
		}

		.period-card__week {
			color: #FF6B35 !important;
		}
	}

	&.disabled {
		opacity: 0.5;
		background-color: #f0f0f0 !important;
		border-color: #d0d0d0 !important;
		// 移除 pointer-events: none，允许点击（点击限制由 handlePeriodSelect 方法控制）
		cursor: pointer;

		.period-card__month-day {
			color: #999999 !important;
		}

		.period-card__week {
			color: #999999 !important;
		}
	}

	&__date {
		display: flex;
		flex-direction: column;
		align-items: center;
		margin-bottom: 8rpx;
	}

	&__month-day {
		font-size: 24rpx;
		font-weight: 400;
		color: #FF6B35;
		line-height: 1.2;
		text-align: center;
	}

	&__week {
		text-align: center;
		font-size: 24rpx;
		color: #FF6B35;
		margin-bottom: 8rpx;
		font-weight: 400;
	}

	&__status {
		text-align: center;
		font-size: 20rpx;
		margin-top: 4rpx;
		font-weight: 400;
		
		// 🔑 status=0 显示绿色（待答复）
		&.status-pending {
			color: #52c41a;
		}
		
		// 🔑 status=2 显示红色（已驳回）
		&.status-rejected {
			color: #ff4d4f;
		}
		line-height: 1.2;
	}

	&__selected-icon {
		position: absolute;
		bottom: -10rpx;
		right: -10rpx;
		display: flex;
		align-items: center;
		justify-content: center;
	}
}

// 日期角标（数量）
.period-badge {
	position: absolute;
	top: -8rpx;
	right: -8rpx;
	min-width: 28rpx;
	height: 28rpx;
	// padding: 0 6rpx;
	color: #ffffff;
	border-radius: 20rpx;
	font-size: 18rpx;
	line-height: 28rpx;
	text-align: center;
	display: flex;
	align-items: center;
	justify-content: center;
	box-shadow: 0 2rpx 8rpx rgba(0, 0, 0, 0.2);
	z-index: 2;
}

.period-badge.badge-pending {
	background-color: #39B54A;
	box-shadow: 0 2rpx 8rpx rgba(57, 181, 74, 0.35);
}

.period-badge.badge-replied {
	background-color: #ff4d4f;
	box-shadow: 0 2rpx 8rpx rgba(255, 77, 79, 0.35);
}

// 全部班期（始终最右侧，点击展开）
.all-periods-button {
	// flex: 0 0 104rpx;
	// padding: 16rpx 6rpx;
	padding: 8rpx;
	bottom: 20rpx;
	width: 70rpx;
	height: 112rpx;
	background-color: #ffffff;
	// border: 1rpx solid #FF6B35;
	border-radius: 8rpx;
	display: inline-flex;
	flex-direction: column;
	align-items: center;
	justify-content: center;
	color: #FF6B35;
	font-size: 26rpx;
	position: absolute;
	right: 0;
	z-index: 2;
	background-clip: padding-box;
	order: 9999; // 始终在最右侧
	box-shadow: -8rpx 0rpx 8rpx 0rpx rgba(0, 0, 0, 0.1);

	text {
		line-height: 1.2;
	}
}

// 占位标签（防止被全部班期按钮遮挡）
.all-periods-button-spacer {
	flex: 0 0 70rpx;
	width: 70rpx;
	height: 112rpx;
}

// 渠道价格信息样式
.channel-price-info {
	padding: 20rpx 30rpx;
	background-color: rgba($primary-color, 0.05);
	border-top: 1rpx solid rgba($primary-color, 0.1);
	display: flex;
	align-items: center;
	justify-content: flex-start;

	.channel-price-label {
		font-size: 26rpx;
		color: $text-secondary;
		margin-right: 10rpx;
	}

	.channel-price-value {
		display: inline-flex;
		align-items: baseline;
		color: $primary-color;

		.currency {
			font-size: 28rpx;
			font-weight: 600;
			margin-right: 2rpx;
		}

		.price-int {
			font-size: 32rpx; // 比右边大4rpx
			font-weight: 700; // 左边加粗
			line-height: 1;
		}

		.price-dec {
			font-size: 28rpx;
			font-weight: 600;
			line-height: 1;
		}

		.per {
			font-size: 26rpx;
			font-weight: 500;
			margin-left: 4rpx;
			color: $text-secondary;
		}
	}
}

// 空状态样式
.empty-dates {
	padding: 40rpx 30rpx;
	text-align: center;

	.empty-text {
		font-size: 28rpx;
		color: $text-secondary;
	}
}

/* 公共卡片样式 */
.card {
	margin: 20rpx;
	padding: 30rpx;
	background: #fff;
	border-radius: 5rpx;
	box-shadow: 0 6rpx 16rpx rgba(0, 0, 0, 0.05);
}

/* 已选班期信息区域 */
.selected-schedule-info {
	background: white;
	border-radius: 16rpx;
	padding: 30rpx 20rpx 20rpx 20rpx;
	box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.08);
	// margin-bottom: 20rpx;
	margin: 0rpx 20rpx 20rpx 20rpx;
}

.info-header {
	display: flex;
	align-items: center;
	margin-bottom: 32rpx;
}

.calendar-icon {
	font-size: 38rpx;
	margin-right: 16rpx;
	color: #555555;
}

.header-text {
	font-size: 32rpx;
	font-weight: 600;
	color: #222222;
}

.info-cards {
	display: flex;
	flex-direction: row;
	gap: 24rpx;
}

.info-card {
	flex: 1;
	background: #f9fafb;
	border-radius: 16rpx;
	padding: 20rpx;
	border: 1rpx solid #eaeef4;
	box-sizing: border-box;
}

.card-title {
	font-size: 28rpx;
	font-weight: 600;
	color: #333333;
	// text-align: center;
	margin-bottom: 20rpx;
}

.card-content {
	display: flex;
	justify-content: space-between;
	gap: 20rpx;
}

.data-column {
	display: flex;
	flex-direction: column;
	align-items: center;
	flex: 1;
}

.data-number {
	font-size: 36rpx;
	font-weight: 700;
	line-height: 1.2;
	margin-bottom: 8rpx;
	min-height: 44rpx;
	display: flex;
	align-items: center;
	color: #333333;
}

.red {
	color: #ff4d4f;
}

.orange {
	color: #FC642F;
}

.green {
	color: #52c41a;
}

.data-label {
	font-size: 24rpx;
	color: #888888;
	text-align: center;
}

/* 待答复的申请区域 */
.pending-applications-section {
	background: white;
	border-radius: 16rpx;
	padding: 20rpx;
	box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.08);
	// margin-bottom: 20rpx;
	margin: 0rpx 20rpx 20rpx;
}

.section-title-box {
	border-radius: 8rpx;
	padding: 16rpx 0rpx;
	display: flex;
	align-items: center;
	margin-bottom: 16rpx;
}

.section-title-icon {
	font-size: 24rpx;
	margin-right: 12rpx;
}

.section-title-text {
	font-size: 32rpx;
	color: #333333;
	font-weight: 600;
}

.application-list {
	display: flex;
	flex-direction: column;
	// gap: 16rpx;
}

.application-card {
	background: #F8F8F8;
	// border: 2rpx solid #39B54A;
	border-radius: 16rpx;
	padding: 20rpx;
	display: flex;
	flex-direction: column;
	gap: 30rpx;
}

.card-divider-between {
	width: 100%;
	height: 1rpx;
	margin: 20rpx 0;
	background-image: linear-gradient(to right, #E0E0E0 0%, #E0E0E0 50%, transparent 50%, transparent 100%);
	background-size: 20rpx 1rpx;
	background-repeat: repeat-x;
}

.card-header {
	display: flex;
	align-items: center;
	justify-content: space-between;
}

.group-badge {
	width: 120rpx;
	height: 56rpx;
	display: flex;
	align-items: center;
	justify-content: center;
	gap: 6rpx;
	background-color: #39B54A;
	color: #ffffff;
	border: 1rpx solid #39B54A;
	border-radius: 15rpx;
	font-size: 24rpx;
	text-align: center;
	box-sizing: border-box;
	margin-right: 15rpx;
}

.group-badge-team {
	width: 120rpx;
	height: 56rpx;
	display: flex;
	align-items: center;
	justify-content: center;
	gap: 6rpx;
	background-color: #FBBD08;
	color: #333;
	border: 1rpx solid #FBBD08;
	border-radius: 15rpx;
	font-size: 24rpx;
	text-align: center;
	box-sizing: border-box;
	margin-right: 15rpx;
}

.agency-info {
	display: flex;
	align-items: center;
}

.agency-name {
	font-size: 30rpx;
	color: #333333;
	font-weight: 600;
	margin-right: 8rpx;
}

.play-icon {
	font-size: 16rpx;
	color: #333333;
}

.rating {
	display: flex;
	align-items: center;
}

.star-icon {
	font-size: 28rpx;
	color: #FFD700;
	margin-right: 4rpx;
}

.rating-value {
	font-size: 24rpx;
	color: #333333;
	font-weight: 600;
}

.card-detail-row {
	display: flex;
	align-items: center;
}

.card-detail-row-team {
	display: flex;
	align-items: center;
	justify-content: space-between;
}

.detail-label {

	font-size: 28rpx;
	color: #666666;
	margin-right: 16rpx;
	margin-left: 10rpx;
}

.detail-value {
	font-size: 28rpx;
	color: #333333;
}

.card-footer {
	display: flex;
	justify-content: space-between;
	align-items: center;
}

.quota-display {
	display: flex;
	align-items: center;
}

.quota-display .detail-value {
	color: #333333;
	font-weight: bold;
}

.reply-button {
	width: 144rpx;
	height: 64rpx;
	line-height: 64rpx;
	text-align: center;
	background-color: #39B54A1A;
	color: #39B54A;
	border-radius: 6rpx;
	// padding: 12rpx 24rpx;
	font-size: 24rpx;
}

.reply-button-team {
	width: 144rpx;
	height: 64rpx;
	line-height: 64rpx;
	text-align: center;
	background-color: #FBBd08;
	color: #333;
	border-radius: 20rpx;
	// padding: 12rpx 24rpx;
	font-size: 24rpx;
}

/* 已答复的申请区域 */
.responded-applications-section {
	background: white;
	border-radius: 16rpx;
	padding: 20rpx;
	box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.08);
	margin: 0rpx 20rpx 20rpx 20rpx;
}

/* 已确认成团区域 */
.confirmed-group-section {
	background: white;
	border-radius: 16rpx;
	padding: 20rpx;
	box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.08);
	// margin-bottom: 20rpx;
	margin: 0rpx 20rpx 20rpx 20rpx;
}

.info-notice {
	margin-top: 16rpx;
	padding: 16rpx;
	background-color: #F8F8F8;
	border-radius: 8rpx;
}

.notice-text {
	font-size: 22rpx;
	color: #666666;
	line-height: 1.5;
}

.registration-button {
	/* 背景色、文字颜色和边框通过动态样式设置 */
	width: 144rpx;
	height: 64rpx;
	line-height: 64rpx;
	text-align: center;
	background-color: #39B54A1A;
	color: #39B54A;
	border-radius: 6rpx;
	// padding: 12rpx 24rpx;
	font-size: 24rpx;
}

/* 底部操作栏 */
.bottom-action-bar {
	position: fixed;
	bottom: 0;
	left: 0;
	right: 0;
	height: calc(120rpx + env(safe-area-inset-bottom));
	background: white;
	border-top: 1rpx solid #f2f2f2;
	padding: 0 24rpx env(safe-area-inset-bottom) 24rpx;
	display: flex;
	gap: 16rpx;
	align-items: center;
	z-index: 100;
	box-shadow: 0 -2rpx 8rpx rgba(0, 0, 0, 0.1);
}

.action-button {
	// flex: 1;
	background: white;
	border: 1rpx solid #D9D9D9;
	/* 胶囊形状关键：设置足够大的圆角 */
	border-radius: 100rpx;
	/* 或使用 50rpx 以上，推荐 100rpx 更圆润 */
	// padding: 16rpx 0;
	/* 水平内边距设为 0，避免文字被挤压 */
	width: 160rpx;
	height: 64rpx;
	text-align: center;
	display: flex;
	align-items: center;
	justify-content: center;
}

.button-text {
	font-size: 28rpx;
	color: #333333;
	font-weight: 600;
	line-height: 1.2;
}

/* 空状态样式 */
.empty-state {
	text-align: center;
	padding: 40rpx 20rpx;
}

.empty-text {
	font-size: 24rpx;
	color: #999999;
}


.section {
	// background-color: $text-light;
	// border-radius: $radius-large;
	// margin-bottom: 20rpx;
	// overflow: hidden;
	// border: 1rpx solid #f1f1f1;
	// box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.03);
	// transition: $transition-base;
	background: #ffffff;
	margin: 24rpx;
	border-radius: 20rpx;

	&-header {
		display: flex;
		// justify-content: space-between;
		align-items: center;
		padding: 28rpx;
		// border-bottom: 1rpx solid #f5f5f5;

		&__left {
			display: flex;
			align-items: center;
		}

		&__icon {
			width: 30rpx;
			height: 30rpx;
			margin-right: 20rpx;
			font-size: 28rpx;
			color: $primary-color;
			display: flex;
			align-items: center;
			justify-content: center;
			background: #eeeeee;
		}

		&__title {
			font-size: 28rpx;
			font-weight: 600;
			color: $text-primary;
		}

		&__add-btn {
			padding: 8rpx 20rpx;
			background: rgba(255, 255, 255, 0.1);
			border-radius: 8rpx;
			color: #FC642F;
			font-size: 24rpx;
			border: 1rpx solid #FC642F;

			&:active {
				transform: scale(0.95);
				background-color: rgba($primary-color, 0.15);
			}
		}

		&__buttons {
			display: flex;
			gap: 15rpx;
		}

		&__btn {
			border: none;
			border-radius: 38rpx;
			padding: 0 20rpx;
			height: 70rpx;
			line-height: 70rpx;
			font-size: 26rpx;
			display: inline-flex;
			align-items: center;
			justify-content: center;
			border: 1rpx solid rgba($primary-color, 0.35);
			color: $primary-color;
			background-color: rgba($primary-color, 0.06);
			box-shadow: 0 2rpx 8rpx rgba($primary-color, 0.15);
			transition: $transition-base;

			&:active {
				transform: scale(0.95);
				background-color: rgba($primary-color, 0.15);
			}
		}
	}

	&-description {
		font-size: 24rpx;
		color: $text-secondary;
		padding: 0rpx 30rpx 20rpx;
		line-height: 1.5;
	}
}

.section-header__title {
	font-size: 32rpx;
	font-weight: 700;
	color: #333333;
}

.section-item {
	padding: 0rpx 28rpx;

	.section-item-top {
		display: flex;
		align-items: center;
		padding: 24rpx 0rpx;
	}

	.section-item-bottom {
		display: flex;
		font-size: 28rpx;
		padding: 0rpx 0rpx 28rpx 0rpx;

		.section-item-left {
			color: #FC642F;
			display: flex;
			flex: 1
		}

		.section-item-right {
			color: #666666;
		}
	}
}

.section-header__icon {
	color: #787878;
	background: #f2f2f2;
	width: 40rpx;
	height: 40rpx;
	font-size: 24rpx;
	border-radius: 4rpx;
}
</style>